{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 查看FashionMNIST数据集的原始内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<PIL.Image.Image image mode=L size=28x28 at 0x20994A4FEC0>, 9)\n"
     ]
    },
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAAcABwBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APn+tbw1oNx4m8QWmkWx2yXD4LkZCADJJ+gFbviL4a63oc7COE3MW4hdn38duD976jNc9daDqllIsc9lKrMu4YGeMkdR7gj8KzcV7H8BtEvV16+1iWCeG1Wz8mOV02pIzupwCeuAp6Z98cZ90aIzLIlw0c0ZJ4KgjHoeOa+evjS9n/wnMcNxBPCYLKONFhA2FNzMpGenDcgd816V4K03wefC+m3NlpVhP+5QSXBiR5fMx825iMg5zwce3FdbOzTwgW90lu6uCm8eYrL02soIyCPQgggEdMGQ3cluiPNK0rJwrRQBNueuMkt+teNfGKxsdY8WWdxNqcNo66eieXMwVsb5DnH415Hp2rajpE5n02/urOUjBe3laMkehIPIrVm8eeLrhNknibVivoLtx/I1UPinxC3XXtUP1vJP8ay5JZJpGkldnduSzHJP41//2Q==",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACS0lEQVR4AWKgA2BkYOD1ZGBgZAHZxcjIAKZBbBBm+quS8v3rj1N/GBiZGP8wMKNIMv91cnnCzuU65+X/vww8/76hSP5iMFVgZtpp2HXm8nUz02PHGUHGQTHjf9cugd//GE7f+cUo8ft0yDSEJCMDw/8TCgyMf34x/Ph3/vYfT0VphLH/GRgY3kt+Z2fl+cH5z8aSSWwHqmsZuJiZvn18p/CPkYnr7z9ZBiaofQwMjMwMPFI/frH++sr/j537K9sldhOE5H9mhnBJJg4Gbtlf7L//cQhvusaCkGT5xXDlBxsXl6rSD2Yunr9PoraeYAGZx8T4+x/DHwaGbV+/s/1/zczxm+H3P2a9jwxMDMz///z6+Y+BwW7ime9v//z78/XrXw6GbwxsX4NAYc3AICSlJhmk/oPpN+czVjbhX1zHeOz+fWR9qcnIYNkkKvCX+cMfrl+M36+HneEVVGC4x/v5GycPHxcj83GpP3+/MTB/Z2DgF0lwy3z24/49VeFfrLxsf+UBY0xqv8vDw87Ayv/4mSiTRACHIrexMdMvJjYGRlYLlpeP+X485mHje/eQ5/uPP+svKwj9+vD77y/Wf4xsaixP/z/mFvnw5jULOysHL9Mbza+P37O/+f3nN6fERwOWC+sTn937wcPGwcb88+//by/+/WX5wfPrw4fffxRfMjIweBWLv/7wl5mNhZnxPysrGysjA+NLBrZ/EpfCGJn+MTA4tYnxMzGz/GV8+f/pvy/MDP9/f2Paff0YJBAYGBg0RN/LPPx1Fx5HFDIAaCTYdiCc4RIAAAAASUVORK5CYII=",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=28x28>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看FashionMNIST数据集的格式\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torchvision import datasets,transforms\n",
    "from deeplearning_train import EarlyStopping,ModelSaver,train_classification_model,plot_learning_curves\n",
    "from deeplearning_train import evaluate_classification_model as evaluate_model\n",
    "\n",
    "\n",
    "# 定义数据转换\n",
    "transform = transforms.Compose([]) # 创建一个空的转换组合，不对数据进行任何预处理或转换操作\n",
    "                                   # 这里使用transforms.Compose([])表示不对图像进行任何变换，保持原始格式\n",
    "                                   # 在后续代码中会加载原始格式的FashionMNIST数据，用于查看其原始数据格式\n",
    "\n",
    "# 加载FashionMNIST训练集\n",
    "train_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,  # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "# 加载FashionMNIST测试集\n",
    "test_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,  # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "\n",
    "# 打印训练集的第一个样本\n",
    "print(train_dataset[0])\n",
    "# 打印训练集的第一个样本的图像\n",
    "train_dataset[0][0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载数据集，处理为tensor格式，查看其形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集图像形状: (60000, 28, 28)\n",
      "训练集标签形状: (60000,)\n",
      "测试集图像形状: (10000, 28, 28)\n",
      "测试集标签形状: (10000,)\n"
     ]
    }
   ],
   "source": [
    "# 重新加载FashionMNIST训练集，应用张量转换\n",
    "train_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,     # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transforms.ToTensor()  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 重新加载FashionMNIST测试集，应用张量转换\n",
    "test_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,    # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transforms.ToTensor()  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 获取图像和标签\n",
    "train_images = train_dataset.data.numpy()\n",
    "train_labels = train_dataset.targets.numpy()\n",
    "test_images = test_dataset.data.numpy()\n",
    "test_labels = test_dataset.targets.numpy()\n",
    "\n",
    "# 定义类别名称\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "               \n",
    "\n",
    "# 打印数据集的基本信息\n",
    "print(f\"训练集图像形状: {train_images.shape}\")  # 打印训练集图像的形状\n",
    "print(f\"训练集标签形状: {train_labels.shape}\")  # 打印训练集标签的形状\n",
    "print(f\"测试集图像形状: {test_images.shape}\")   # 打印测试集图像的形状\n",
    "print(f\"测试集标签形状: {test_labels.shape}\")   # 打印测试集标签的形状\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 把数据集划分为训练集55000，验证集5000，测试集10000，并给DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 从训练集中划分出验证集\n",
    "train_size = 55000  # 定义训练集的大小为55000个样本\n",
    "val_size = 5000  # 定义验证集的大小为5000个样本\n",
    "# 设置随机种子以确保每次得到相同的随机划分结果\n",
    "generator = torch.Generator().manual_seed(42)  # 创建一个随机数生成器并设置种子为42\n",
    "train_subset, val_subset = torch.utils.data.random_split(\n",
    "    train_dataset,  # 要分割的原始训练数据集，60000个样本\n",
    "    [train_size, val_size],  # 分割的大小列表，55000个训练样本和5000个验证样本\n",
    "    generator=generator  # 使用之前创建的随机数生成器，确保每次得到相同的随机划分结果\n",
    ")\n",
    "\n",
    "# 查看train_subset的大小\n",
    "print(len(train_subset))  # 打印训练子集的样本数量\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([55000, 1, 28, 28])\n",
      "训练数据集均值: 0.2856\n",
      "训练数据集标准差: 0.3527\n",
      "数据集中图像总数: 55000\n"
     ]
    }
   ],
   "source": [
    "def calculate_mean_std(train_dataset):\n",
    "    # 定义一个函数，用于计算训练数据集的均值和标准差\n",
    "    all_images = torch.stack([img_tensor for img_tensor, _ in train_dataset])  # 使用列表推导式从数据集中提取所有图像并堆叠成一个张量\n",
    "    print(all_images.shape)  # 打印堆叠后的图像张量形状\n",
    "    # 计算通道维度上的均值和标准差\n",
    "    # Fashion MNIST是灰度图像，只有一个通道\n",
    "    # 对所有像素值计算均值和标准差\n",
    "    mean = torch.mean(all_images)  # 计算所有图像像素值的平均值\n",
    "    std = torch.std(all_images)  # 计算所有图像像素值的标准差\n",
    "\n",
    "    print(f\"训练数据集均值: {mean.item():.4f}\")  # 打印计算得到的均值，保留4位小数\n",
    "    print(f\"训练数据集标准差: {std.item():.4f}\")  # 打印计算得到的标准差，保留4位小数\n",
    "\n",
    "    # 检查数据集大小\n",
    "    print(f\"数据集中图像总数: {len(train_dataset)}\")  # 打印数据集中的图像总数\n",
    "calculate_mean_std(train_subset)  # 调用函数，传入训练子集作为参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 55000\n",
      "验证集大小: 5000\n",
      "测试集大小: 10000\n",
      "批次大小: 64\n",
      "训练批次数: 860\n"
     ]
    }
   ],
   "source": [
    "# 创建数据加载器\n",
    "batch_size = 64  # 设置批次大小为64\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_subset,  # 使用训练子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=True  # 打乱数据集，每次迭代时，数据集的顺序都会被打乱\n",
    ")\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    val_subset,  # 使用验证子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱验证集数据顺序\n",
    ")\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_dataset,  # 使用测试集创建数据加载器，10000个样本\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱测试集数据顺序\n",
    ")\n",
    "\n",
    "# 打印数据集大小信息\n",
    "print(f\"训练集大小: {len(train_subset)}\")  # 打印训练集的样本数量\n",
    "print(f\"验证集大小: {len(val_subset)}\")  # 打印验证集的样本数量\n",
    "print(f\"测试集大小: {len(test_dataset)}\")  # 打印测试集的样本数量\n",
    "print(f\"批次大小: {batch_size}\")  # 打印每个批次的大小\n",
    "print(f\"训练批次数: {len(train_loader)}\")  # 打印训练过程中的批次总数\n",
    "\n",
    "# DataLoader的作用和优势解释\n",
    "\n",
    "# DataLoader是PyTorch中用于加载数据的工具，它提供了以下几个关键功能：\n",
    "\n",
    "# 1. 批次处理（Batching）\n",
    "#    - 将数据集分割成大小相等的批次（batch）  # 批次处理使模型训练更高效\n",
    "#    - 每次迭代返回一个批次的数据，而不是单个样本  # 批量处理数据可以加速训练过程\n",
    "\n",
    "# 2. 数据打乱（Shuffling）\n",
    "#    - 通过shuffle=True参数启用  # 设置是否在每个epoch打乱数据\n",
    "#    - 有助于模型泛化，防止模型记住数据顺序  # 打乱数据可以提高模型的泛化能力\n",
    "\n",
    "# 3. 并行加载（Parallel loading）\n",
    "#    - 通过num_workers参数控制  # 设置数据加载的工作进程数\n",
    "#    - 使用多个CPU核心同时加载数据，提高效率  # 并行加载可以减少数据准备时间\n",
    "\n",
    "# 4. 内存优化\n",
    "#    - 只在需要时加载数据，而不是一次性加载整个数据集  # 按需加载数据减少内存占用\n",
    "#    - 适合处理大型数据集  # 对于大数据集尤其有用\n",
    "\n",
    "# 5. 预处理集成\n",
    "#    - 可以通过Dataset的__getitem__方法或DataLoader的collate_fn参数  # 提供数据预处理的方式\n",
    "#    - 在加载数据时自动应用变换和预处理  # 实现数据加载和预处理的无缝集成\n",
    "\n",
    "# 在我们的代码中：\n",
    "# - train_loader: 用于训练，启用了数据打乱以提高模型泛化能力  # 训练加载器配置了数据打乱\n",
    "# - val_loader和test_loader: 用于评估，不打乱数据以确保结果一致性  # 评估加载器保持数据顺序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55040"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*860"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([20, 100])\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch  # 导入PyTorch库\n",
    "m=nn.BatchNorm1d(100)  # 创建一个一维批归一化层，归一化特征维度为100\n",
    "# 这行代码创建了一个BatchNorm1d对象，用于对一维特征进行批量归一化\n",
    "# 参数100表示要归一化的特征数量，即输入张量的特征维度\n",
    "# BatchNorm1d通过计算每个特征维度上的均值和方差，对每个mini-batch的数据进行归一化处理\n",
    "# 这有助于加速训练过程、提高模型稳定性，并允许使用更高的学习率\n",
    "x=torch.randn(20,100)  # 创建一个随机张量，形状为[20,100]，表示20个样本，每个样本100个特征\n",
    "print(m(x).shape)  # 将张量通过批归一化层处理，并打印输出张量的形状\n",
    "\n",
    "# 批归一化(BatchNorm1d)的作用:\n",
    "# 1. 加速网络训练 - 通过归一化每一层的输入，使梯度更稳定\n",
    "# 2. 允许使用更高的学习率 - 减少了内部协变量偏移问题\n",
    "# 3. 减少对初始化的依赖 - 使网络对权重初始化不那么敏感\n",
    "# 4. 具有轻微的正则化效果 - 添加了微小的噪声，有助于泛化\n",
    "# 5. 在每个小批次上独立进行归一化操作，使每个特征维度的分布更稳定"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建CNN模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义MNIST分类CNN模型\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # normalize\n",
    "        self.transform = nn.Sequential(\n",
    "            transforms.Normalize([0.2856], [0.3527])\n",
    "        )\n",
    "        # 第一组卷积层 - 输入1通道，输出32通道\n",
    "        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # 第一个卷积层，1通道输入，32通道输出，3x3卷积核\n",
    "        self.conv2 = nn.Conv2d(32, 32, kernel_size=3, padding=1)  # 第二个卷积层，32通道输入，32通道输出，3x3卷积核\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 第一个最大池化层，2x2窗口，步长2\n",
    "        \n",
    "        # 第二组卷积层 - 输入32通道，输出64通道\n",
    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # 第三个卷积层，32通道输入，64通道输出，3x3卷积核\n",
    "        self.conv4 = nn.Conv2d(64, 64, kernel_size=3, padding=1)  # 第四个卷积层，64通道输入，64通道输出，3x3卷积核\n",
    "        \n",
    "        \n",
    "        # 第三组卷积层 - 输入64通道，输出128通道\n",
    "        self.conv5 = nn.Conv2d(64, 128, kernel_size=3, padding=1)  # 第五个卷积层，64通道输入，128通道输出，3x3卷积核\n",
    "        self.conv6 = nn.Conv2d(128, 128, kernel_size=3, padding=1)  # 第六个卷积层，128通道输入，128通道输出，3x3卷积核\n",
    "        \n",
    "        \n",
    "        # 全连接层，输入128*3*3，输出512\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 256)  # 第一个全连接层，输入维度为128*3*3=1152，输出维度为256\n",
    "        # 这行代码创建了一个全连接层，连接卷积层输出和最终分类层\n",
    "        # 输入维度128*3*3来自最后一个池化层输出的特征图尺寸(3x3)与通道数(128)的乘积\n",
    "        # 输出维度256是一个中间特征表示，用于进一步降维到最终的10个类别\n",
    "        self.fc2 = nn.Linear(256, 10)  # 第二个全连接层，输入256，输出10（对应10个数字类别）\n",
    "        \n",
    "        self.init_weights() # 初始化权重\n",
    "\n",
    "    def init_weights(self):\n",
    "            \"\"\"使用 xavier 均匀分布来初始化卷积层和全连接层的权重\"\"\"\n",
    "            for m in self.modules():  # 遍历模型中的所有模块\n",
    "                if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):  # 判断模块是否为卷积层或全连接层\n",
    "                    nn.init.xavier_uniform_(m.weight)  # 使用xavier均匀分布初始化权重，有助于解决深度网络的梯度消失/爆炸问题\n",
    "                    if m.bias is not None:  # 检查偏置是否存在\n",
    "                        nn.init.zeros_(m.bias)  # 将偏置初始化为零\n",
    "\n",
    "    def forward(self, x):\n",
    "        # normalize,x.shape=[batch_size,1,28,28]\n",
    "        x = self.transform(x)\n",
    "        # 第一组卷积层\n",
    "        x = F.relu(self.conv1(x))  # 应用第一个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv1 output shape: {x.shape}\")  # 打印第一个卷积层输出的形状\n",
    "        x = F.relu(self.conv2(x))  # 应用第二个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv2 output shape: {x.shape}\")  # 打印第二个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第一个池化层\n",
    "        # print(f\"pool1 output shape: {x.shape}\")  # 打印第一个池化层输出的形状\n",
    "        \n",
    "        # 第二组卷积层\n",
    "        x = F.relu(self.conv3(x))  # 应用第三个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv3 output shape: {x.shape}\")  # 打印第三个卷积层输出的形状\n",
    "        x = F.relu(self.conv4(x))  # 应用第四个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv4 output shape: {x.shape}\")  # 打印第四个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第二个池化层\n",
    "        # print(f\"pool2 output shape: {x.shape}\")  # 打印第二个池化层输出的形状\n",
    "        \n",
    "        # 第三组卷积层\n",
    "        x = F.relu(self.conv5(x))  # 应用第五个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv5 output shape: {x.shape}\")  # 打印第五个卷积层输出的形状\n",
    "        x = F.relu(self.conv6(x))  # 应用第六个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv6 output shape: {x.shape}\")  # 打印第六个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第三个池化层\n",
    "        # print(f\"pool3 output shape: {x.shape}\")  # 打印第三个池化层输出的形状\n",
    "        \n",
    "        # 展平特征图，准备输入全连接层\n",
    "        x = x.view(x.size(0), -1)  # 将特征图展平为一维向量，x.size(0)保留批次大小，-1自动计算剩余维度，将三维特征图(通道,高,宽)转换为二维张量(批次,特征)，以便输入全连接层\n",
    "        # print(f\"flatten output shape: {x.shape}\")  # 打印展平后的形状\n",
    "        \n",
    "        # 全连接层\n",
    "        x = F.relu(self.fc1(x))  # 应用第一个全连接层并使用ReLU激活函数\n",
    "        # print(f\"fc1 output shape: {x.shape}\")  # 打印第一个全连接层输出的形状\n",
    "        x = self.fc2(x)  # 应用第二个全连接层（输出层）\n",
    "        # print(f\"fc2 output shape: {x.shape}\")  # 打印第二个全连接层输出的形状\n",
    "        \n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "批次图像形状: torch.Size([64, 1, 28, 28])\n",
      "批次标签形状: torch.Size([64])\n",
      "----------------------------------------------------------------------------------------------------\n",
      "torch.Size([64, 10])\n"
     ]
    }
   ],
   "source": [
    "model = CNN()\n",
    "\n",
    "# 从train_loader获取第一个批次的数据\n",
    "dataiter = iter(train_loader)  # 将训练数据加载器转换为迭代器对象\n",
    "images, labels = next(dataiter)  # 从迭代器中获取下一个批次的图像和标签数据\n",
    "\n",
    "# 查看批次数据的形状\n",
    "print(\"批次图像形状:\", images.shape)  # 打印图像批次的维度信息，通常为[batch_size, channels, height, width]\n",
    "print(\"批次标签形状:\", labels.shape)  # 打印标签批次的维度信息，通常为[batch_size]\n",
    "\n",
    "\n",
    "print('-'*100)  # 打印100个连字符作为分隔线，提高输出可读性\n",
    "# 进行前向传播\n",
    "with torch.no_grad():  # 不需要计算梯度，减少内存使用并加快计算速度\n",
    "    outputs = model(images)  # 将图像输入模型，获取模型的预测输出\n",
    "print(outputs.shape)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "各层参数量明细:\n",
      "conv1.weight: 288 参数\n",
      "conv1.bias: 32 参数\n",
      "conv2.weight: 9216 参数\n",
      "conv2.bias: 32 参数\n",
      "conv3.weight: 18432 参数\n",
      "conv3.bias: 64 参数\n",
      "conv4.weight: 36864 参数\n",
      "conv4.bias: 64 参数\n",
      "conv5.weight: 73728 参数\n",
      "conv5.bias: 128 参数\n",
      "conv6.weight: 147456 参数\n",
      "conv6.bias: 128 参数\n",
      "fc1.weight: 294912 参数\n",
      "fc1.bias: 256 参数\n",
      "fc2.weight: 2560 参数\n",
      "fc2.bias: 10 参数\n",
      "模型总参数量: 584170\n",
      "需要训练的参数量: 584170\n"
     ]
    }
   ],
   "source": [
    "# 计算模型的总参数量\n",
    "total_params = sum(p.numel() for p in model.parameters())  # 计算模型中所有参数的数量\n",
    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)  # 计算需要求梯度的参数数量\n",
    "# 查看每层参数量明细\n",
    "print(\"\\n各层参数量明细:\")\n",
    "for name, param in model.named_parameters():\n",
    "    print(f\"{name}: {param.numel()} 参数\")\n",
    "print(f\"模型总参数量: {total_params}\")  # 打印模型的总参数量\n",
    "print(f\"需要训练的参数量: {trainable_params}\")  # 打印需要训练的参数量\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "288"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*3*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n",
      "训练开始，共训练43000步\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08ac4035be0e4cef8c5ededf68d25f2a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/43000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "早停触发! 最佳验证准确率(如果是回归，则是损失): 90.8000\n",
      "早停: 已有5轮验证损失没有改善！\n"
     ]
    }
   ],
   "source": [
    "# 定义损失函数和优化器\n",
    "from torch import optim\n",
    "criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数，适用于多分类问题\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)  # 定义随机梯度下降优化器，学习率为0.01，动量为0.9\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "model = model.to(device)\n",
    "\n",
    "early_stopping = EarlyStopping(patience=5, delta=0.001)\n",
    "model_saver = ModelSaver(save_dir='model_weights', save_best_only=True)\n",
    "\n",
    "\n",
    "model, history = train_classification_model(model, train_loader, val_loader, criterion, optimizer, device, num_epochs=50, early_stopping=early_stopping, model_saver=model_saver, tensorboard_logger=None)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAHACAYAAABqJx3iAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuTlJREFUeJzs3Qd4W+XVB/C/JNvynolX4uy9J1mMhCwIUPbeUEYZJVCgpQU+Ni1l7z3LHmGGkJAQQvbee9oZthPHe0mW9D3nvbqybMu25CnZ/9/zKJI177Ud6x6d855jcDgcDhAREREREbUhxtbeACIiIiIioqbGQIeIiIiIiNocBjpERERERNTmMNAhIiIiIqI2h4EOERERERG1OQx0iIiIiIiozWGgQ0REREREbQ4DHSIiIiIianOCEADsdjsOHz6MqKgoGAyG1t4cIqJ2Q2ZKFxYWIjU1FUYjPxvT8X2JiMj/35sCItCRN5O0tLTW3gwionYrIyMDnTt3bu3N8Bt8XyIi8v/3poAIdOQTM31noqOjfX681WrF3LlzMW3aNAQHB6M9aa/73l73W3Dfue9Nue8FBQXqgF7/O0wavi81HPed+859bx+szbjf3r43BUSgo5cFyJtJQ99QwsPD1WPb0y9Ye9739rrfgvvOfW+OfWd5VlV8X2o47jv3nfvePlhbYL/re29iwTUREREREbU5DHSIiIiIiKjNYaBDRERERERtTkCs0SEi/23vWFFRAZvNBn+pBw4KCkJZWZnfbJO/77vJZFKP4xocIiJqaxjoEFGDWCwWHDlyBCUlJfCnwCs5OVl1wmpvB+6N2XdZLJqSkoKQkBAEgkWLFuG///0v1qxZo34HZ82ahXPOOafK9+L//u//8NZbbyEvLw8TJkzAa6+9ht69e7vuc/z4cdx+++344Ycf1AyG888/Hy+88AIiIyNbaa+IiKipMdAhogYNS9y3b5/KBsiwLjlA9ofAQrarqKhIHay2t+GWDdl3CQgkYD169Kj6eUogEAjft+LiYgwdOhTXXXcdzjvvvBq3P/XUU3jxxRfxwQcfoHv37njggQcwffp0bN26FaGhoeo+l19+uQqS5s2bp7Jh1157LW688UZ88sknrbBHRETUHBjoEJHP5OBYDqylh71kA/yFbJNsmxzMBsIBuz/se1hYmGr7eeDAAdfj/d3pp5+uTrUFb88//zzuv/9+nH322eq6Dz/8EElJSfj2229xySWXYNu2bZgzZw5WrVqFUaNGqfu89NJLmDFjBp5++mkVvBMRUeBjoENEDdbegom2qi39HCUzlZmZiSlTpriui4mJwZgxY7Bs2TIV6Mh5bGysK8gRcn/5PqxYsQLnnntujectLy9XJ/dhdUKyQXLylf6Yhjw20HHfue/tTXvdd2sz7re3z8lAh4iI2gwJcoRkcNzJ1/ptcp6YmFjldmnIEB8f77pPdU8++SQefvjhGtfL1O/GZDWldK694r63T9z39mdeM+y3t+uDGegQERHV47777sNdd91VJaMjpZvTpk1TU78b8mmkvPlPnTq1XU1KF9x37jv3vX2wNuN+61n1+jDQISJqoG7dumHmzJnq1FgLFy7EpEmTkJubq8qqqGGk85zIyspSneR08vWwYcNc98nOzq7yOGmTLp3Y9MdXZzab1ak6efNuzBt4Yx8fyLjv3Pf2pr3ue3Az7Le3z9d2CrOJiLwwceLEJglMhCxml05d5D+ky5oEK/Pnz6/yyZ+svRk3bpz6Ws6l7bS0p9YtWLBANXSQtTxERNQ2MKNDRFSta5cM3JQ1G/Xp2LFji2wTVSVttHfv3l2lAcH69evVGpsuXbqoQPaxxx5T7bL19tLSSU2ftdO/f3+cdtppuOGGG/D666+r8orbbrtNNSpgxzUiouZ/n22pkRRtPqOTtWkBip8/AcM3P4TsV0/H/pfPxo5XL8Gm16/F6jdvwaovnkLOoco3TCJq2B+tEktFq5zktb11zTXX4Pfff1eDIeWPrJzef/99df7zzz9j5MiRqjxp8eLF2LNnj2pPLIvYZTbN6NGj8euvv9YoXZNWxjp5nrffflt17ZIF6nKg/f333zf4+/r1119j4MCBapvktZ555pkqt7/66qvqNaQltJRpXX311a7bvvrqKwwePFi1j05ISFBdxWT+TFuwevVqDB8+XJ2ErJ2Ryw8++KD6+t5771XDQCXbJj83CYyknbR76+yPP/4Y/fr1w+TJk1Vb6RNPPBFvvvlmq+0TEVF7sfFgPsY+MR9//2pjs79Wm8/oHDmcgWHFe6Eq3nP31rzDYQBbH0d6UHcUdJ2MtDHnIabXWMBoaoWtJQpMpVYbBjz4S6u89tZHpiM8xLs/ZRLg7Ny5E4MGDcIjjzyirtuyZYs6/8c//qFmqPTo0QNxcXHIyMhQB8CPP/64CjRkFstZZ52FHTt2qKxBbaQzlwys/O9//6tms8hgSplRI9kGX0hZ1UUXXYSHHnoIF198MZYuXYpbbrlFBS0SsMnB/l//+ld89NFHGD9+PI4dO+YKxGQQ5qWXXqq2Q4KuwsJC/PHHHz4Fhf5efljXvkjAKT9f/Wfsifw8OByUiKjlbTyYh8yCMnVqbm0+0AnqcRL+u+9pWI4fRmp8GCJQjjCUItRRhjB7MeJyN6GfdSu6VOwD9rytTgXGGBxLOw3dL3sWBnNka+8CETURmacSEhKisi36ovPt27erczkols4w7gfCQ4cOdX396KOPYtasWSpDI2VOtZEgRIIM8cQTT+DFF1/EypUrVamUL5599lmVbZCyK9GnTx9s3bpVBVDyGunp6YiIiMCZZ56JqKgo1QGsZ8+erkBHFtefd9556Nq1q7pOsjtEREStbX1Gvjof2jmm2V+rzQc6g3r3QN9uaZg9e7b6dNZTl4aDBw9ix5JvELJnLoaWr0a0PR/RBz7H5sWnYNDky1tlu4kCSViwSWVWWuu1m4L78Egh5U6STfnpp59cgUNpaakKMOoyZMgQ12UJRKT1cPUOX97Ytm2bKp1zN2HCBFUqJ2uIJCiTIEYyUBJESZtjCYzk9SRAk8sS3EyfPl3ddsEFF6hMFRERUWtndMTQtObvMNrm1+h4o3Pnzph88V9x0j9/RO6t27A5aIC6vqRQ+0EQUd2kVEjKx1rj1FQLGiUocXf33XerDI5kZaTsSxa7S+BgsVjqfJ7qH6bI9kk3r6YmWZy1a9fi008/VetzJCg76aSTVDcxk8mkZhfIuqMBAwaoErq+ffuqRftEREStpai8AruPFqnLQzoz0GlxXRPjYAvRvvE2a/PXDhJRy5LSNcmI1GfJkiWqREzWuEiAI6Vu+/fvR0uRzmCyDdW3SUrYJJAR0hlOmgzIWhwJxCTbJG2S9QBLMkCyZmjdunVqvyVwIyIiai2bDuZDllimxoSiY1TN2WRNrc2XrjWEwxSinVsY6BC1NdK9TGaqSNAi3dRqy7ZIN7NvvvlGNSCQoEHWyjRHZqY2f/vb31THMFkbJM0Ili1bhpdffll1WhM//vgj9u7di5NPPlmVpMnXsn2SuZH9kzkyUrKWmJiovj569KgKnoiI3GUcL8ETs7fhT0NTcfrgyiG7TanMasM/v9kM5Bowo1leITAzGw9/vwXdOkTg1km90N7K1oa0QDZHMKPjgcOkRZi2ivLW3hQiamJSkiYZESnpkjk4ta25kWYAEkBIRzMJdmSty4gRI1psO+W1vvjiC3z22WeqS5y0TpaGCZJlErGxsSoQO/XUU1UAI62RpbW1tKOWdTqLFi1S6xIlA3T//fer1tSnn356i20/Efm/vUeLcOHry/Dz5ky8MH9Xs73O+0v345t1hzFrvxF7jraNNveNkV9ixRVvr8CXaw7i6bk7cCS/FO2ptXRLrc8RzOh44AjSAh27lYEOUVsjB/6SHXGnBw/VMz96GZju1ltvrfJ19VI2Ty2PZc1MQ1smn3/++erkicx9WbhwoetryeYUFBSoyxL4yNwYIqLa7MgsxOVvr8CxIu1YZ8/RIlhtdgSbmvYz8IIyK17/fY+67IABLy7YjVevqNr8pT3JKSrHle+sxNYj2t9r+bP/44YjuOHkHmgPNuiNCFqg45pgRscTZ+kaKli6RkRERG3L5kP5uOTNZSrI6Z8SjUhzEKw2B/Yda/psy9t/7ENeiRXJ0WYY4MDszVnq9duj7MJyXPLmchXkdIgMwdXjtPb/32+QoY7tI8g7mKtlrwYx0Gk9xmAto+Ng6RoRNZGbb75ZrQnydJLbiIhawpoDubj0reXILbGqT9U/vWEM+iZHqdu2ZxY26WsdL7bgnT+0Ye3/PL0vRnTQstbPztuJ9uZ4OXDZ26uwK7sISdFmfHbjOPx1cm+YjAZsOpTfLEGmv5at9ewYgejQmuNemgNL1zwJCtXOK+puI0tE5C1ZXyPrgzyRNTVERM1t2Z4cXP/BKpRYbBjdLQ7vXjMaUaHB6JMUpQKgnRLoVM5JbjQpWSu22DAwNRrTByQhe4cd64+bsGB7NtYcOI6RXePRHhw4XoKXtphwvLwEnePC8Mmfx6JLQri6bUKvDli08yh+2HBYBT7to2wttsVek4GOB0bnGh2DjaVrRNQ0pPuZnIiImous85OF/79syVRrPzwdaJZZ7TixVwe8edVINYtM9E2KVOc7spouo5NVUIYPlmrrGO+e1hdGowEdw4Dzh6fiizWH8N9fduDTG8Y22Sy0pu4S98C3mzEkLRZXjtXKyxoqM78Ml7+9CsfLDeiWEI5PbhiL1Ngw1+3S7U4CHSlfu/3UXnV+P7YdKcDLv+3GPdP6qm5tLanCZseTP29Hz46RuGxMlwY9x4YMveNay5StCQY6HhhD9ECHGR0iIiIKjCDn0R+34d0ldQ8GPrVfIl69fARCg7V5XKJvcrSrQUFTeXnBbpRX2DGyaxwm9u2IiooKdf2tE3vg2/VHsHzvcSzZnYMTe3eAv/l1W5bqiCanzPxSFag1NCD7bFU6sgrLkRTmwCfXj64S5IhpA5MQMsuI3dlF2HakEANSPWf47XYH/vbFBrW+JzIkCP+5YAha0oLt2Xhn8T4EmwyYMTgZseHO9ew+/H7qpWsSQLYUBjoemIK1X0IjAx0iIiLyc3IQfP93m/HJCq1d/h2Te6tytOqiQoMwvmcCgqp1VtPX6KQfL0GJpcKV6WnMbB45wBf3TK8aJMiB/uVju+C9Jfvx37k7MKFXgt9ldSQA073y2x6UWux44Mz+DdrOpc7nmphi9zggU9aqTOrbEb9syVJZndoCHWkBrndqW7r3GFra986GCdK0Qrbl0hN8y+ocyitFTrEFQUYDBqS0XLk2mxF4YArR1ugY7WxGQERERP5LSoru/mqDCnLkOPyp84fgzql9cMaQlBqnk/t0rBHkiPiIENdB+M6sokZv0/O/7lIHxCf17oCxPRJq3H7LxF4ICzapUqZft2XD3yzbowUSZzgHqEqW7F/fblYBpS8kaFyXkasu94mp/bF/GtpJncs6HU9jCuRn/Oy8Ha6vM46XqmCypZRYKjDf7eck2+krPZvTLyWqSjaxuTHQ8SAoWAt0THZra28KERERkUcy9+aOz9bjm7WHVPeu5y8ehotGpzXoufo6M0CqIUEj7M4uxKx1B9Xlv03r6/E+ElRdO6GbuvzM3B0+BxDNSTIP+3NK1Pfz3+cPxlMXDFEBpASSd3+5QQUd3lq1P1cFfKkxoUiomcxxmdw/EREhJvXaa9Nrzl6bte6QGrQaGx6s2oGLpc5grCXM25qFUqsNHSK1nVi2NwfZBWUNXJ/TcmVrgoGOB0FmrXTNZGfpGhEREcEvF8z/5X9r8NOmI2rdxCuXjcDZw7TMQEPopW6NbTH93LxdkLhl6oAkDKtjLcZNJ/dUpXTyej9s9J85Mkt2awHE4E4xqiPdRaPSVAApgc836w6pwNJS4V2ws9T5XON6xqtgqTaS4Zg2MNljtkRe64X5u9Tlm0/piSn9E2uU1zW3H5zbdOkJaRjRJVYbcrrxSIM6rg1joNP6gp3NCEwOBjpEVFW3bt3w/PPPe3Vfqef+9ttvm32biNr6Af1jP27F7E2+HVi1Fpkd869Zm9Sn4M1Fyptu/t8aVfZlDjLizatG4bRB2oFyQ/VzrtPZ2YjOa1sO56vASw7q/zatT533jQkPxo0n9VCXn5u3U5VHNdZrC/fg3cV1N2PwpgW3kLVDOgkgpYGDBJSyf7d9starLNRS53ON615/G23pviYkgHDPGn2+Kl0N2ZQs2NXjumF8zw6u5/ZU5lbd23/sxVNztqvsX0PklVjw+86j6vJZQ1Nd2+nLkFOb3YHNh7T1RUPSWq7jmmCg40GwM6MT5GDpGhERUWv6cNl+vL14H+77ZpM6YPJn2YVluOTNZfh4RTqe/Hlbs73OlsMFWLjjKEKCjHjvmtGY1Lfxrev7OAOdxrSYfmauNgj0rCGp6Ofs5FaXa0/sjg6RIapU7Jp3V6GwrOHHXfuPFeM/c7bjkR+3qhk9DSGBg57RmeAMKHTTBybjratGqe/53K1ZWLX/eL0BwubD2rqUsT3qD3Rkno6Uph0rKlcd6USpxYaXFuxWl6X1dFiICSO6xqrgVu4nw0frciCnGI/9tA2vLtyDv/xvLcorbPDVnM2ZqvxOAmHJ+s0YkgKjAVifkef1OqG9x4pRVF6h1mX16qi1Mm8pDHQ8CAnVhjgFO6x+/0eViIiorZIDXzlIE/mlVjVHxF8dzivFxW8sdy3mT88pafCn6N4cOIohnWIwvlfTtGfu45ylc7SwXGWlfCXBhbQglhKvu6bWnc3RRZqD8MaVoxBlDsLK/cdxxTsrkV/SsGBHL40SMqPHm2xHdbIOJruwXAUzI7rG1bh9Yt9EV0ajvnI7CVZkE3olRiIp2jmIvg7ymqcPSqlSKvbR8v1qezrFhuGS0VqXM3OQCaO7xVcpjavNj27lZdIy+88frFbBky/0/ZRsjkiMCsW4ngk+ZXU2HdICvkGdoj02w2hODHQ8MDszOmZYVMqciOohf80txa1z8uHN7M0330Rqairs9qoHH2effTauu+467NmzR11OSkpCZGQkRo8ejV9//bXJvk2bNm3CqaeeirCwMCQkJODGG29EUVHlJ3ILFy7ECSecgIiICMTGxmLChAk4cOCAum3Dhg2YNGkSoqKiEB0djZEjR2L16tVNtm1E/kjmduS5Hfjqn7b7GwlqLnpjGfYdK1YHpfKJe4XdoUqOmsO+o1qg070Jh0ZKS+ku8eENmqcjQYUEF+LCkZ19GmYpc3ZkiKZkM2TB+qVvLUdOke9dbzdkaAfTQp/R4yt9gf+ornG1dgbTA53ZmzLrDGT155J23t7Sn/vnzUdUsKkH+XdM6a0CId14Z1ndEmdpXG2+X68FIhePSkN4iAl/7DqGa95bqbIr3mYo9VI+fdvcL3vbfW2Ts2xtaAuvzxGco+NBsLO9dIihQnWZiDDz20RUJ2sJ8ETlH8EW9c/DQIh3b6oXXnghbr/9dvz222+YPHmyuu748eOYM2cOZs+erYKOGTNm4PHHH4fZbMaHH36Is846Czt27ECXLg2bBK0rLi7G9OnTMW7cOKxatQrZ2dn485//jNtuuw3vv/++GqZ3zjnn4IYbbsCnn34Ki8WClStXuuY2XH755Rg+fDhee+01mEwmrF+/HsHBwY3aJiJ/lltswdt/aOstTugWrz7xlwO7m07pCX+y52gRLn9rBTILytTk+49vGIvr31+lFtnvO1bUpMGITp5XdO/YtM8tpUkyS2dHZoHrU3tvSFAhwUWIyYjbJ/f2+XUHd47B5zeOw+Vvr1CzYi5+czk++fMYJHqRCdFtdGZ0OseFqQCzITN69EC6ruBEbpNyu2NFFnV/yfLU/VzeZ9xO6B6PpGgzsgrKccOHq1WQ36NjBM4bXrXJhPacO7B8b45az+MpSyLB6o6sQvUz+ecZ/XHhqM649r1VWLHvOK58ZwXev/YExITV/R7y08YjqrGENJVIcwbB4rSBKbj/283qd1zWdHma2eRu46GWHxSqY0bHA6Me6MDqc4qPiPxXXFwcTj/9dHzyySeu67766it06NBBZUuGDh2Km266CYMGDULv3r3x6KOPomfPnvj+++8b/drymmVlZSp4kueXzM7LL7+Mjz76CFlZWSgoKEB+fj7OPPNM9Zr9+/fH1Vdf7Qqw0tPTMWXKFPTr109tmwRtsr1EbdXri/aoT56lne5Dfxqorlu177jXHa9awvbMAlz8xjIV5PROjMQXN41TGR05OBV7nZmXpiaZI9GjiYMovSHBDh9m6ahszlwtm3PZmC5q/xtChpZ+ftNYJEeHYnd2kcqQSbtlb8jBvr4e5pkLhzZoRo8sVdDXxtRVDihBxQznfJ3aSreyCspUGZzEWN6sz9FJ2d8Zg7UPDdcc0Obv3DmlT41ARusIF4TCsgq1XsuT7zccUuen9O2oAppR3eLx8Q1jVOZsXXoeLntreb0livr+uWdz9EYSp/RJrJI1qo38d912RMsQDu3cso0IBFMVnpi0rmtmWJHL0jWi+gWHa5mV1nptH0hmRLImr776qsrafPzxx7jkkktgNBpVRuehhx7CTz/9hCNHjqgsS2lpqQoyGmvbtm0qMJGyNJ2UpkkZnWSMTj75ZFxzzTUq6zN16lQV1Fx00UVISdHeUO+66y6VAZLASG6TQEcCIqK2SGZ0fLB0v7p897Q+6gA8ISJETVaXRdDyyXdd5D5v/bHX48yTIKMR153YDSO7encAOndLpppT40DNMln5dFw+dZdJ7x9dfwISnHNGenSIrBKQNCUJLPQ1Ot2dr9NU+jSg85oEExJUSHBx66RejXr9nh0j8eXN41T5mjQouOj1ZfjmlvH1rnGRdVFlVrta6yPrV2RGj5R9yYyeyf0SYZTV8/XYerhArQOTdUOy9qkusl7lw2UHMHdLllriUL3MTS9bG5Qag9jwEFit3q87+tOwVDWgVEiQrw8trR4QySBW6ey3ZM8xDK2WKZHfkR82aOtz3IMUmWHz6Q1jVUZHAiRpnPG/6z1nzqTRgARE8q07c0jNbThraIpa9yNreKTDXm2Zs8MlMu/JoQIsvTSyJTGj40lQiDozo4IZHSJvyB84KR9rjZMPZQlCStHkTUCCmYyMDPzxxx8q+BF33303Zs2ahSeeeEJdL+VhgwcPVmVkLeG9997DsmXLMH78eHz++efo06cPli9frm6TAGzLli0444wzsGDBAgwYMEBtK1Fb9PJvu9WB6/AusTjVeaA61llO5M2gxIe+36LKbn7ZklXjJO2BH/xui1fbIdmje7/eiDlbMj0+lwQ5UtYjB496kCP0crXmCHQk2JNP8uVPX9eEpj1wdLWYziz0ajG/tFiWYEJIcCEtkBtLSqQk2JHvoWR0PlqmrVP0pmxtUKcY9bvSkBk9+u/VmO7x9S6YH9klTg0BlYzjwh01s0ZLneuD9LU0vpCshzQwEPdM71NrkKaX1+lraNxtOJivShDDQ0xqGKk7CZ4+u3GcKpGTAFHKBKWRRnX6900CKk+BkMxJkuD2QE4JNh6sXB9VXXqRwRVk+VJG2FQY6HgSpP1AzQYpXWt8X3ci8h+hoaE477zzVCZH1sL07dsXI0aMULctWbJEZVXOPfdcFeAkJydj/37tU+XGklI0aSgga3V08nqSSZJt0Mk6nPvuuw9Lly5VJW7uZXYS+Nx5552YO3eu2gcJjIjaGvkk+dOVWhb1nml9XQdHertf/SCyrsdLRkeODx/+00A8fu4g1+nRswciyGhQn2bL2pr6yDoLCWZkTYb78+inFy4ZpoIcKeVxp6+daY5AR3/O1JiwWhfMN5QEFzIrprC8Aofz6598LwfDEkxIUCHBRVNJiQnDXyb29DqwlQN7oWc23Gf0PP/rLo+Zver0hf3edLGT4EPvQla9fE0CRH1+ji/rc3Ty+/7+taPx2Y1jcWq/pDrbUQtpc129bbReTjalf5JqMlGdBFJf3jRerWeS3ycpE5SGGp6eo3rZmk6ed8qApHq7rx1wBjqtUbYmGOh4YtIyOqKsvHk6phBR65EMjmR03n33XVc2R8jal2+++UZlciQoueyyy2p0aGvMa0qQJetuNm/erBoiSGOEK6+8UnV527dvnwpwJKMjndYkmNm1a5cKkKR8TpoWSFc2uU0CJGloILcRtTUvzt+lSl1kIbn7Qaf+Cfa6jNw6h0vqB11ykHn1+G64fExX1+nKcd1wYu8OXneM0p/rzCGpVZ5HP8kgSZltUp2+duZIflmTDML01HFNXwfUlIJNRlU+JqQhQV0keJAgQkhQUT3Yayz95y1BTH3zdaR0rvrBtMzoiY8IUQfyX689WG/mTtZ/ub9uffRAZ/627CrbJxkOyURJwDi6W80W1d7oHBeuMil1kTVhHSLNKvO59kBelbVGP26sO0gRXRLC1ZoyaaAhzRsk2JG1UWJXVqEKYGUf6hpEWznk9HCt41jcMzqtgYGOJ0GVqVdrWf2faBBRYJFGAPHx8WptjAQzumeffVY1LJDSMSlxk/UyeranscLDw/HLL7+oLm/StvqCCy5Qnd+kIYF++/bt23H++eerzI20nr711ltVcwTpspaTk4OrrrpK3SZrd6SpwsMPP9wk20bkLyTLoh+U3j2tMtMppExLFrpLELRqv7ZQ2xM9gJE1BJ7IMEs9iKmrPEtK12V9Tl3PVRtZlxHnPPDff8y7oYre2ttMjQh0egetHZl1Z7zk5yRBhAQTElQ0NTnYl5+5HEDXNZxT1sjoQ07du3rJWptbnFmhF37dVeewTMkASpddWQfWt54OYrqBqdEq2CyvsKu1Mjo9mzM8Lc5jNqWpSOansnytMuu1Yl+Omr0jDQhO7tOxzudIjQ1TwY4ETdJQQ9bsSIMNPcA/uXdH9btcm5P7dEB0aJDqErfSGSi6Ky6vQJYzX9BaGR02I6ijGYEoK2NGh6itkXKxw4drfprbrVs3tf7FnQQb7nwpZat+ECXlcNWfXydZndrW3ISEhKgyO6K27tl5O1U72yn9EzG8S5zHA7sv1xxU5UyneDiI2+n+SfRAz8HJtIFJMM8yqo5oUsIm6zo8keGXxRabCq5GVNsWb8vActPzVDAwIDUaTd5aupkCHel+hg11NySQoOHF+bvVZQkmJKhoDvLzlgyJtK+urYxLfoYSDEl2Q9bNuLtibFfVolzK8D5ZkY5rJ3SvsxW0tNT2pnGB/vsoGQ3JaklgcN6Iztpz6fNzGrA+x1eS9ZTXlrK7u6oF+qcPSq4ye0ex24CS40DxUaA4G7BXILHzCfj8pnG4wtna+5I3l6s5UHpjhLrI8FIZcvr56nT8sOFQjZbkW44UwAEDkqPNPrUKb0oMdDwxGlGBIAShAlaWrhERETU76XolDQTEXVOrZnN0cvCoAp1a1uno6wqk9W1tpVRRocGqwcHPmzPVQWFtgU5lZii1QYuopSPaWhXoFHm17zIk8rZTe6mDR2/W6HR3lpg1NT2jIQFjbT5dka7Ks2RBuwQTzUXKDz9dmVHnoFi9EYFkDKr/nGQN0+2Te+Ffszbjld924/yRnREdWvP3YlkD19Sc5Qx0Fu86plo1x4YFY3kj1ud4JB+YSYBiKwdszsY4obGqEY/+GlK6J40RZGaO/F6Lc/tHAZu+Arb9ABzdoQU3JbJt1bKYxiDEp43F10NOxX1IxLdHJKg3IDTYqNb4qNeXx+buB47vAwoOAUVZQGGmOn/o+CH8nzkLFRtMWLfvBGyOGIdtEWNQFBSL/TlFrnbYVfYn/yCQtVlbE99zEpoTA51aVBiDEWSvQIWFgQ4R1STNDKSszJOuXbuqDmlE5L1vnCVrMwYn15oB0Q/sZGZKfom1SjAjGVTX3I96PomWT+L1QOfvp/Wr8Sl+QZkVC5zdtOpa51AX1ywdLxoSPPzDFtWqWtoo1xU4SOZC2i6r52/OjI6UEWYXeRxGKWuOXv5tj7r818m9m7whgjs9QyBBV05ReZXOdtXX59S2BuSiUWl4c9FelRm68u0V+OC6E6qUY8n+yLovPUPiC1nPJCVsW5yBqmT+pCuedCOTbnz1koP+wiNAzm7naY/ztFsLJCSwUcFNteAkMhnoNAJpnUbg3BgT5ud3UmuMgspyMK18Lv4UtgYnfL25MjCqwgCExwMRHYGKMi2AObAYYQcW43kAD4bH43drf/SMMSDi3ce02y21B+tqapLzv8/wwoXqZHcYsN7RE/NtIxBu7IPLzTuAn7/WgpvMTUCZc01Rj0kMdFpLhUH+E5TCWs41OkRU05/+9CeMGTPG423BwU27KJeoPdjg/GS+rk5TEgj07BihhjEu25tTZaG03lJXDjKl9K0uk/olqnIrKWlam56rhim6k/koskBdulP1T/FuzUZ1emlZfUNDJZjQ2/PKWpG6Ah1pAyzbJZ/cy/qK5iClehEhJlW2tz+nGL0Sq+7/+0v341hRuZqJcuHINDQnKUeTltcS6MjPW5pCVKd/74amxdTaYOGVy0ao2THyO3LpWyvwP7eZR7K2RNZ9yX53iTUDGauAnXOAA0uAjn2Bk+8FYjrVuo0SCEug8/26Q7AX56AjcjEhLQ4hRQe1TIzDDpQVIzF/A4yrDgMF6ZXZETmvaMAH6kWZwI7Z6vScfB0K5H+TjChLNk4KtmtxkSxJSugN9D8L6HYiEJmkBTfhCYDJ7fBfAqs9C4Bd84D9fyDeehznmpYAEtu44hsDEN0JiO8OxHTWnisq2XW+rzwSm3btQ9qxP9Dl6CIkFO3ACMNujDBq5Y3YXm37jUFAh77a97eZMdCphd0Yon5JmNEhIk+ioqLUiYgaT022P6R1+RpWywGre1tdCXRknY57oKOXmknL2/oWgUsWQtbqyCBQyQJVD3TcJ8I3dPZHZaBTpLJNtT3P7qNFaiG8exlWbfTskCzSl6GRzUGyW72TolTQJQ0J3AMdGaj5xu971eWZU3rXXAPSDCb0iEN+5n4c2rAAcAQDeelA4WEgIhElMT0RkpMDM5KrZnRUpiTTlUEYlLkJi1OysOBwMPYejce7L8/F9WeejPjUXli/PRMzjMtxnXkHDM/82Vne5ZS+DNjwGTDmJuDEO4Gwmmu1zhoQg31zF+Cqw/MwIPMArpSlKPLrI+kRJ/noa5xc0L51VRlMQFw3IKEnkNCr8jy6s9YcSzoBm4IrL0uW5shG4PBa4NAaFO9diYiSDMRYtJK1TfZuSBh1AVLHXeRdIKFerydwwg3SgUvb54yV2r5KYCPbFtulSqOu6mTlU/c+QwCcrV1RcBjYNRf27T+jbP9KhKYOgDFlCJA0CEgerG1XHc/XlBjo1MImgY788bWUt/amEPktbwbKkf/jz5Fa265s7WBfsiw9OtS99kTK12Qqvd7dypeWutXXV0igM1sGiJ45wFWiJSVS+poQvYVwQ3RL0AKdgrIK5JZYVXcyT/TSK/37IGstalvcv+9o8zYicF+nowU6BThjSGVTh3f+2KuCHenSJa21G00OrA+u1NaQlOZqC+VLj1eeFx/Fv/IP44HQCkCq5bSKORcZlzrHLJ9LG2F6u6t2AC3lWJmbgZKq63rkO3aWXJBvrRTrfPWiun6m/CM/Gn3mpTkG6HWqlgXZ9DWQvhRY8gKw5gPgpL8BJ9wIBIdqmZBV7yB13f/w7+DKgZlStmUwmmCQrIkEMUYTHEYTChyRiOoyGMaEHlrwoIKI7loQIYGMt+S+XcdpJym9KyzHhMdnob8xHRmOjjDEdcWisyb5PExbkf3q2QTlZNGpwMhrYBtyOebNno0ZM2bA2EqVDgx0amF3dl6zyX9CIvJYmlVSUoKwsOYpn6CWIz9HwZI7ai2Vk+2j6+16NbZHvDqGk5kfWQVlqpxNyo+kxa20upWWt944sVcH1QL6WJFFBU16K97ZmzNV4CQLqBsTUMh8HekCJuVx0pAgPqJq1qj6sEshnzlsPpRf6wyVykYEzRzoONfp6G2b9QDwncX71OW7pvZpUEbJ4KiA4eAqIGMJsG8RkL5CW2RfBwk/rQ4TDjsSkNylN8wdugPRKSpjc2TPRoTn70KMoQTIlVKwfW4vZtRKt5KdWYSoFLWQvihrL7Zu3YyEiix0Nko2yILd9lSkjD4HEYNmAF3GVgYeo64Hdv4C/PoQcHQbMO8BYOWbWsZl72+ulyoM64wXC07Gl7ZT4AiLx9oHplb5/lRYrVjYTAf8HaPMSExKwbIs7Wd2y5CGZyHbIgY6tXA4h4baGegQ1SBzXWJjY5Gdne2aAeMPf1hluKfFYkFZWZlqId2eNGTfJZMjQY78HOXnKT9XotbgmmzvxVBBWUg+KDUGmw7lq25Z5wzv5Co1k1a39XUtc1+7MWNwCj5eka4erwc6P9QzEd4XEpBIoCPrdEZ2ja8zyNPXxcjXtQU6zT1Dp3qgszOrchH6awv3qO2TYLTGEElbhVrfgc1fA3sXamtTJFiQYylVchUME4yYkbkFQevLPCysHwlEJABh8dpCef1c1pPEpOHij/Zg7cFC/HfYEFw4qnJd0EMfrcYv2Zl4bHIiruhVBhzbqb2mlEgl9geCa34QJ/nCtPxSXP7WCuw9VoQIlCElsSN+PeuUmt8IeV/rexrQeyqw4VPgtyeA/AztJOtW5PrRN6A85SS8++RvsMGB03okNFtZYV1ZTv1n1ZgsZFvEQKcWDHSI6pacrL3R6cGOP5AD99LSUpVl8ofAK1D2XYIc/edJ1BpcLYK96VTlnK8igY6UmEmwIh2vGnKQJ8GMBDq/bM7EY+cMUi2CV+4/ro5vz/RxSKgnkhGSGTB6JsbTsMvtR7SsybkjOuF/y9OrZHhqzejUVt5XUa6Vgck6jpSh3pdEFWZpnbCcXb4G2ooxzrgFIccrUL4TKDTF4oflO2BEuBrkqv7G2O1AxgotuNn6rdaCuA5G58kRFgdDt5OA7icD3U8BOvSut8xqXO9CFehI5s090NEaERjQu2dPoHuC9pxeSIkJc82O2ZFlUIMx6954EzD8CmDQ+cC6/2lldoMv1MrPpGmCGq7ZAb/tOIqJfet5rmYgrylNIqRxg5yoEgOd2jhL1+zyR4OIapA3upSUFCQmJsJqtcIfyHYsWrQIJ598crsrw2rovst9mcmh1uR+sD/Ey+np43t1wBuL9qoD38W7jyKvxKo6dFUfWFif0d3ikRITiiP5Zfh951GkO1s3a9c3vixXX29UW6Cz9XA+gu2l6BFuw7ldy7FqRTqsBzKAfcWAtVTryCXHIaZgWAxmdMnfjERDMHrZk4FjOdpME2nXK2tS5PzYDjUE0rXWpMcpQK8p2sm9c1jRUWD/Iq18TE7Hq66Sl3DzU31J0SeAHBGtCALsQUYYvk/QuneV5Wuvr5PF6wPO1k6SialwtkZWJ6tq7rR4035MOP9mBIf4thB9Qs8OeOW3PSqw1Rs7ZBeUqZ+bJE9qm4VUX8nXFzePU0Hu9IFeftAjGSJZtO/BUxcMVdvXGhkVGZ77+hUjMCCl5iyh9o6BTm2c3SAczOgQ1UkOkv3lQFm2o6KiAqGhoe0u0GnP+06BTaaxV9gdSIgIUS1+vTG6WxyCTQY1tFIOgMWZQ1J8LhmS9UDyuLf+2KfK1/RApynK1tzX0qhAp6wApjn3YfK2XxG06x7AUoLhliJsC5WBkAC+A36RQw/5fPWDms8lcccnevDxUR0vGhqjrU+RrMO277WTSBwApA4HDq8DsrdWfYzc3xxdpctXRoEN+RYDUiIMMJYcRZyhCEbZUMnc6NmbkCig/5lapqPHxDozSA6rFfl7Zmuv5aMRXeNUh7fswnLVcU/afuuZr96JUYiopXlDfWLCgnHR6KZpkS2Bk5RRtgYJbk4b1PgMZFvEQKcWBr3tnXwiQURERM1iY0Zl2Zq3n0ZL++jhaXGqzGzNAW3YY0M/SZfHSaAzd0ummqciwdLp1degVF+PkrkB2L9Em4MiB/ndJni8q76WJujYdjjenAnj8T1qjYgKZirnLMIBAwwhEThuNaHEHoy4mBhEREQCweFa4GGvQH5BPjJz8hATZEWytBuTD2JlXYvesldOclnmnMjslsPrgd2/ArvnAQdXa8GNe4CTNNhZPnay1sFLAiQ373y/RZVDBVUYVCA6sVcs3r+4Z2WgI50Tuk7QOnU1M2kHPqprnMrgSVtxCXT0ckdvs4DUPjHQqYUhyPkft55uIERERNRw+sBHXw9Yx/dKUIGOkEzQiC7ere+pTrqrdUsIx35nNke6senDJF2BzaE1anq8Cm5kXYr7pPjV7wCDLgCmPaq11XUj23V+0BI8anobhuPlcER3wsoOF2LEpLMRHB6D89/diK05drx69QRM6p+MRz9fj1nrDmHmkN6YOaVPlef6ZOEe/GfOdpwzIBXPXzK87p2StsadR2qniX/X2jXLUEgJdJKHALJGRoIkLxoSSJAj7pw+EIiK1QZFtgJZlyWBjpSHXTWumyujM8TLdV3UPrWvtkQ+MAZrf+QMXKNDRETthBxEfrT8QIu+5nq9EYEXHdeqDw51z8o0dG2CPM69VK1K2VruAeCtScC704D5jwB75mtBjmQ/+pwODL5Iy8ts/gp4aRTwx7PamhpRYUHQnHvxTNArCDeUIzf5RFRcvwCZMSNU9qUgogvW5ISgFKEYkqYNohzqDPb04M+dtKiusxFBXaSD2eALgMkPAgPPqTfIcQ90xPSBSV43imgusi5LLN97XLX/1jM6w3z8vaH2hRmd+gIdO0vXiIiofbjnyw2qHbKUCfVPiW721ysos6rWyw3J6EhgJHNzZCDn2cMat6bmT8M64aXfdiM0yIRpA5O0K6VN8pfXaoMrZf2KlHjJEEkp10oaqHXiEuNuBWbfow2+nP+w1pVr4n3AiteBQ6vVXV6oOBcJQx7AxbJI32mzM5jpHBfmyiDp2Qk5iNcX3bf0DB1dn6QomIOMsNjsuGtqX7S2IZ1i1CBVGVg6Z3OmakARYjJWCciIqmOgUwujs/e6gaVrRETUDtjtDmQVau95u7KLWiTQ8XSw7y1ZnP7BdScgt8Ti27bK2pJq2R9Z8/HuNaNV4BQlC9uXvgTMe1Bb6yIL+C/+n7b2xZPUYcB1vwAbP9cec3wP8M2ftdtCY/B5lwfx3MYUXJtTVm8ma0BKNIKMBjXEVBotdI6TxThVA53mnqGjk6DivWtHq2+XPwQTQSYjxnSPx/zt2Xjt993quv6p0er3gKg2Pv12PPnkkxg9ejSioqJUS9lzzjkHO3bsqPdxX375Jfr166e6AQ0ePBizZ8+Gvwtytj402S3qjz8REVFbJtkVKQkS+5xZFn8tW9MN7xKHU/s5MzDVydoamSmzZZY26PHzK4AXRwCPxAOvjgcWPKatvZF5MAAm9U3EyJRQ4Os/A3Pv14KcoZcB1/5ce5CjkyG9wy4Fbl8DjLsNMAZpc2xuWgR7r2keW0xvzKi5NkkW3etBhXv5mmQxJPgR3Voo0NEHUbqXCLY2vXxt86ECdT6MjQioKTM6v//+O2699VYV7Egb03/+85+YNm0atm7diogIz//xli5diksvvVQFSWeeeSY++eQTFSCtXbsWgwYNgr8KCtGaEYSgAmUVNtXhhYiIqK3KKbbUWA/S3Dwd7DeILLbPklkym53nm4Cj27UZLp5kb9FOi/4LRKUAfU/XhlcuehrI2qQFKtOf1Gam+LL2JzQamP44MPEfQHCECoC6d8jxHOi4uoZVDfJkLcyWwwXYcDBPDUMV+52PTYwyq0xLeyUNCdxV/94RVefT/5Y5c+ZU+fr9999XmZ01a9aoIXWevPDCCzjttNNwzz33qK8fffRRzJs3Dy+//DJef/11+CtTiFa6ZoYVpRYGOkRE1LblVgl0WiajU9vBvlckmFn+OrD3t6qDK91JsJHYD0jsDyQO1M7jugIZK4HtPwG75wOFR4DV72onEd4BuOjDWltGe8VcWeqll5plHC+BpULLHh0tLFdroSSGGlwtyJOGBJ+sqAwCq6zPacFsjj/qmxSl5i3pQfnQNGZ0qG6NOnrPz9f+E8bHx9d6n2XLluGuu+6qct306dPx7bff1vqY8vJyddIVFBS4Jn83ZAK7/hhfHmuUT3Pkb5XBisLSckSbA7MGtCH73ha01/0W3Hfue3M8L7WvjM7eY8U1FsN7YrXZ8e7ifVUe625k17hap87LwX5mfgn6GQ9ieM4xYOs6IGe31v6412TPM1qkzGzXL8CyV4D9f1S9LbZr5SyZ5EHauVwnZWXVxfcAhl6izaKR59kxG9g5F4hNA85/u/5SNR8HSUaEmFBssSEjt1Rdt/GQdvzUq2NkjQyNHvRtOpSvSudlqKn8PESPFmpE4K/kezG2ZwJ+2nhEfd96NKQDHbUrDQ507HY7Zs6ciQkTJtRZgpaZmYmkpKr1s/K1XF8bKXN7+OGHa1w/d+5chIdXLszzlWSSvNUjew8Gq9I1K3759TdtOFcA82Xf25L2ut+C+94+NfW+l5Ros0WofWV0CssqVPDSoZ4GAT9vzsSTP2+v9XaJk+bOPBm9k9wWs2duwsBDnyL0kxewybwZEYZywH3prgQey18BgsKA7icBvaZqHc/keulkJsGQenKT1ip5xNVaQ4BqAy+9IoFU76naqZlIsCid0mRdiV6Ctsm5xsRTJqt3YiTCgk0oKq/A3mNF6JUYxYyOm1N6d1SBzoiucSrwIWqWQEfW6mzevBmLFy9GU7vvvvuqZIEko5OWlqbWA0VHRzfoE0l58586dSqCg4O9eoxxbTZw6GO1Rmf0uAlqoFggasi+twXtdb8F95373pT7rmfUqe2rnpWRg+v6Ap0th/Nd60rGdq9a3bF8b44a6vjsvJ147YqR2nyZ359C0OLn0Mth0+5kAMqM4QjtMhLoNAKI7wkcXAXs/lUrKds1Vzu5M8cAI68GxtzUpJmX5iSzbyTQ2ZdTglRntqa20ivpLjaoUzRW7c/Fhox8Z6DTiBk6bcz5Izurltcn9fafJgnUxgKd2267DT/++CMWLVqEzp3r/iOTnJyMrKysKtfJ13J9bcxmszpVJ2/ejXkD9+nxIeGuNTpWuyHgD5oa+70LVO11vwX3nfveVM9H7S+jo3deG92t9tJ0sSOzUJ1fOLIzrhjbtcptO7MKMf35RSrrs3v9IvRaci9wdJvENjgSMxI/mCbh8yNJuOasKbhyfI/KB0oQIz2Ns7cCu+ZpQU/6ci2oGXsLMOwywBxYB/x6JmZ/TjFSgmRtUkGd3eYk06MCnYN5OG9EJ1cXPGZ0AJPRUON3jahJAh2p17399tsxa9YsLFy4EN27d6/3MePGjcP8+fNVmZtOPnWU6/1akBZoSelaqdX5yRMREVEbddwZ6Eg1kHSZ1teF1GWnM9DxNGdFBk6eN7gDemx9Gd2//VGK3oGIjqg47b9YsceI1zaGIddhxZC0eM81bzKUU04nzgTstsoBnQGop3Ntzb5jJegTB+SVWhFsMqBfiuf5NJIhE5IRk7VMsr5Hfi5d4gO8jp7InwMdKVeT9tDfffedmqWjr7OJiYlBWJjWpeyqq65Cp06d1Dobcccdd+CUU07BM888gzPOOAOfffYZVq9ejTfffBMBEegYKlDAQIeIiNq44yVaoCPDN6W9cX0tpmXujnQO04OaGjJW4cljtyEkaKf6MqfH2Ug4/zk4QqKRs3U2ckvqPtivIoCDnKoZnRKkBxtc32dzkOf9ks5rYtvhAuzI0oLJtPhwDsck8pFP/2Nee+011Wlt4sSJSElJcZ0+//xz133S09Nx5MgR19fjx49XwZEENkOHDsVXX32lOq758wwdxaQFOmZYUGJhoENERO0joyOd0rxpMa1nc1JiQhET5ixxlJKzfYuAj84F3pmCkOM7URgUjxstd+IvpX+BI1zL3qQX1X+w35boQz6zC8uxK99Q7+wgydzEhgertShS+ufeppqImrF0rT5S0lbdhRdeqE4BJShEnUkzApauERFRewp0Plx2QGUfbHaHWhPhiZ5pUGVrUlomc2kWPwccXlvZFW3oJSge+y8sfHkjLPuO449dxzCue6wr0KltjUpbEx0arBo7HCsqx/qc+vddOrXJOp1FO4+qDmOCjQiIfMccaG2CQivX6DCjQ0RE7STQkS6jUiIlwy0P52lzX2prRGCEHRcaFwKvnAB8caUW5Mj75+gbgL+uBc55FcnJnXDFGG3x+NNzd6gPTfVAp66sRlujZ2RKbIYq63Bqo5ev5Zdqs6ykRTURteDA0DbNFOIaGFrGjA4REbVh8j6nl2l3iDKjW0I4dmYVqYYEsjbEE0vGWnwb8iyG7NunXSFzbCTAGXMzENmxyn1vmdQTn61Kx8aD+fhlazYynFVx9R3styWyTmfl/uPqcniICT071p2hqT5jh6VrRL5jRqfermssXSMiovaRzZHmAFHmINfi+X1HPTQkKC+CY84/8fixv2KIcR9sIdHA1EeBO7cAkx+oEeQIKdu6boLWqfWhH7bBYjcgwouD/bbEPSMzKDW61pLA6hkd1+MZ6BD5jIGOF6VrbEZARETtIdCJCw9R60P09SA1GhLsmAO8OhaG5a/ABAd+sI2D9S8rgAl/Bcx1d0+74eQeiA4Ncg0mHejFwX5b4h6oDO5U//DzxOhQ1ehBhAYbkRytXSYi7zHQqa90DSxdIyKi9hHoxEeEVCmTcs3SKTkOfHEV8OnFQH4GyiI64xrLvXgu5h8IjUv16jWkM9tNp/T06WC/LXEvPRvSybu1Sfoapm4JETC2o6CQqKkw0KmndM1sqEBpeUVrbw0REVGzyS2pGujoZVaujM73twNbv9M6qU24A5+N/gIL7cM8DgqtyzXjuyHB+RrD2tH6HNEloXIOztA07wKdEV3iap9TRET1YjOCegIdYbVqA9GIiIjaopwiZ+maHug4sw+H8kpRfngzzNt/lKbHwHVzgLQTsOXLDQ06AI8wB+H1y4fhgznLMLV/ItoTmRf04sVDsGTFGnSK1Yas1+eqcd1U97uzh3Vq9u0jaosY6NQzMFRUWMpbdVOIiIhaIqOjZ1vkPCo0CIVlFShf+CzUO2L/s1SQ4z5Dp5+PGR09k3O4U+3zedqyyf0SUb63/pmEurAQE26f3LtZt4moLWPpWj1rdERFee1zBIiIiAJdjlszAiENCWRNSWdDNiJ3favd6aS71Jnd7sBOZ6DTpwGBDhFRS2GgUxujEXZjsLpoY+kaERG1YbnOQCchsvJDPilfu8n0I4wOG9DzVCB1uLo+I7cEZVa7Wm/StZYZO0RE/oCBTh3szvI1OwMdIiJqRxkdMTC6DBeZfte+OOlvruu3Z2rZnN6JkQgy8TCCiPwX/0J5Ub5mt3KNDhERtYOMjnONjpiY+yXMBiu2Bw8Auk5wXb/TGej0ZScwIvJzDHTq4HBmdBwVDHSIiAKFzWbDAw88gO7duyMsLAw9e/bEo48+CoejchG4XH7wwQeRkpKi7jNlyhTs2rULaO8DQ/VApzQXPfZ/pi6+ZjtbFu247rvduT7H19bSREQtjYGOFy2mWbpGRBQ4/vOf/+C1117Dyy+/jG3btqmvn3rqKbz00kuu+8jXL774Il5//XWsWLECERERmD59OsrK2t/fe2kuUL3rGla+BZO1GNvsXfBdySDkl1prZHTYiICI/B0DnToYgkK1CzaLeiMgIiL/t3TpUpx99tk444wz0K1bN1xwwQWYNm0aVq5c6crmPP/887j//vvV/YYMGYIPP/wQhw8fxrffOjuMtSMSxOhvcbGyRsdSDCx/TX39v+Dz1fyc/c7BoeUVNtcQUZauEZG/4xydOhiCtYyOGVaUV9hVP3siIvJv48ePx5tvvomdO3eiT58+2LBhAxYvXoxnn31W3b5v3z5kZmaqcjVdTEwMxowZg2XLluGSSy6p8Zzl5eXqpCsoKFDnVqtVnXylP6Yhj21q2fkl6lzm5hgcNthWvQtT6XE44rpjd8hkoLgAu7IKMCA5QmVzKuwOdd8O4aaA3/eWxn3nvrcn1mbcb2+fk4FOHYxBlYFOqdXGQIeIKAD84x//UIFIv379YDKZ1Jqdxx9/HJdffrm6XYIckZSUVOVx8rV+W3VPPvkkHn744RrXz507F+HhDW+xPG/ePDSXCjuwLc+AXtEOhNXxbr9HxWxBMDusmPPjd5iy9RmEAdgQORHG/DxV/DFv+QYEH1qH1UdlrY4JHYKt+Pnnnxu1fc257/6O+94+tdd9n9cM+11Son1AUx8GOnUwOAOdEGegQ0RE/u+LL77Axx9/jE8++QQDBw7E+vXrMXPmTKSmpuLqq69u0HPed999uOsubWCmkEAqLS1NlcRFR0c36NNIefOfOnUqgoO1mW1N7fPVB/H2iq24elwX3D+jX633m7c1G9iyHp0TY3F6p50I2pALR2QyBl72GE5efgTLftmJoLhUzJgxBFvn7gJ278PYfmmYMWNAg7arJfbdX3Hfue/tad+tzbjfela9Pgx06uIKdCpQaqlo7a0hIiIv3HPPPSqro5egDR48GAcOHFBZGQl0kpOT1fVZWVmq65pOvh42bJjH5zSbzepUnbx5N+YNvLGPr0tWodZgYGdWcZ2vkV+ufZDXKcyGoKXPqcuGCX9FcFgkeiVpQdyB4yXqOXYf1dbn9E+NafR2N+e++zvuO/e9PQluhv329vnYjKAuzvbSMkeg1GJv7a0hIiIvSxqMxqpvb1LCZrdrf8el7bQEO/Pnz6/y6aB0Xxs3bhzaiqJy7QO6jNwSr1pLX13wOpCXDsSkASO0zFf3DhHqfN/RYtXEYYeztXQfNiIgogDAjE5dWLpGRBRwzjrrLLUmp0uXLqp0bd26daoRwXXXXaduNxgMqpTtscceQ+/evVXgI3N3pLTtnHPOQVtRVKYFOofzSmG12RFsMtYa6EwzrsIJebNVhzWc+zpgjlS3dYkPh9EAFFts2HusGAdzS9X17LhGRIGAgU5dGOgQEQUcmZcjgcstt9yC7OxsFcDcdNNNakCo7t5770VxcTFuvPFG5OXl4cQTT8ScOXMQGuocK9AGFDtLrqV19JG8MnRJ8Nw0oSLvCP4d/Jb2xYS/At1OdN0WEmREWnw4DuSU4JctWqOGxChz5WBRIiI/xkCnLqaQyq5rFgY6RESBICoqSs3JkVNtJKvzyCOPqFNbVeRce6OXr3kMdBwOnHfwScQbipAb3Q9xk/5V4y5SviaBzpzNWqDTl4NCiShAcI1OXZwDQ0MMFShjRoeIiAJIUVnlnIn047Ws01n1NoaWrUK5Ixg7xj/jqmRw16ODVsa28WC+OmfZGhEFCgY6dQkKcZWulTCjQ0REAaTYPaPjKdA5uhOYe7+6+O+KSxCSOtDj83TvqDUk0PVhRoeIAgQDHW+6rnGNDhERBWjXNZHhbCLgUmEBvrkBqCjDEscQvG+bjoRa1t30cHZe0/VjoENEAYKBjjela7CydI2IiAI20KlRuvb7f4Aj6+EIjcVd5TfCAWOtDQb0FtPCYAB6JzLQIaLAwEDHi9I1s0EGhjLQISKiwCAzb4rdAp2D7oGOlKwtflZdzJ38X2QhHsEmA6LMnvsTJUeHIjRYO1zoGh+OsBBTc28+EVGTYKBTF5auERFRACqvsKNC+ko75RRbKgOfVW8BDjvQ5zQcTp2urooLD1Gd6DwxGg3olqBldTgolIgCCQMdL+fosBkBEREFYtlaVKiWqVHDPssLgfWfajeMuUkNCxXx9czF6dlR67zG1tJEFEgY6HgV6LC9NBERBQ49exMeYkJX5/wctU5n4+eApRBI6AV0n4jcEu8CnRtO7oGzhqbikhO6tMDWExE1DQY6deHAUCIiCuCMTqQ5CGlxWqCTkVMMrHxLu8PoG6QmDTlF3gU6w9Ji8dKlw9EpNqy5N52IqMkw0PFqYCjX6BARUeAoKnMLdOK1QMeYsQQ4uh0IjgCGXaqu8zajQ0QUiBjoeLlGh4EOEREFimKLFuhEuAU6gw5+od045CIgNMbVpEBvRkBE1NYw0PGidE3W6LB0jYiIAkVRuc2tdC0MycjB8JLF2o0n3OC6X64z0EmIZKBDRG0PAx0vStfYXpqIiAKxGYGe0bk0aAFMsMPRdTyQNNB1P2Z0iKgtY6DjxcBQtUaHGR0iIgq4NTomdIoy4TLTAvV14eBrq9zPldHhGh0iaoMY6HgxMJTtpYmIKCC7roUGIXTXT+hoyEeWIxZ7Okyscj99jk4cAx0iaoMY6HjRjICla0REFKila3pL6U9tpyIjv3KQqN3ucHVdY0aHiNoiBjo+dF1zOBytvUVEREReZ3S6WfYCGcthgwmfVExGhgwNdcovtcLufFuL5RodImqDGOh4UbpmNlSoIKe8wt7aW0REROR1oDMi+yt1vjthErIRVyXQOe7M5kSFBiEkiIcDRNT28C+bFxkdV/kaGxIQEVGAlK5Fowg9j8xWXx/pe6U6z8gtqbE+h8NCiaitYqDjZaCjZulwnQ4REQVIRucs03IE2cuAxIEI63miuj7jeKnrPgx0iKitY6DjxcBQ93U6REREgTAwdIRxl/ZF/7OQlhChLh7KK0WFzV410OH6HCJqoxjo1MVgqFynw9I1IiIKoNK1gYb92hepw5AUHYoQkxE2uwNH8svU1czoEFFbx0DH285rMjSUGR0iIgoAFWXF6G04qH2RMgwmowGd4sKqrNNhoENEbR0DHS/L19QaHWZ0iIgoAHS27IHJ4IAtvCMQlaxdpwc6zs5ruQx0iKiNY6BTn6BQdcahoUREFAgsFXb0dexVl+3JQ7UybABd4sOrNCTIcQY6cQx0iKiNYqBTnyA9o2NFGQMdIiIKgPU5gw371GVT6jDX9Wl6oOMsXct1ztFJYKBDRG0UA536OJsRhBgqUMLSNSIiCoDW0oOMWiMCY6fhruvT4vSMjhbo5BQxo0NEbRsDHS+bEZhh4RodIiLyeyUlRW6NCIa6rtdL19KdpWvM6BBRW8dAx+tAhwNDiYjI/9kytyDYYEMeooGYzq7r0+K1ZgTHispVIwK9SoEZHSJqqxjoeN11jWt0iIjI/wVlblDnu4N6uRoRiJiwYESZg9TljYfy1XmwyeC6joiorWGg423XNZmjw9I1IiLyc6HHNqvzDHPvKtcbDAZ0dpavbcjIU+dx4SHqeiKitoiBjrcDQ1GBEmZ0iIjIz0Ue1wKdw+F9a9zWxVm+pgc6nKFDRG0ZAx1fSteY0SEiIn9WYUFM4S518Whk/xo3653XNhxkoENEbR8DnfpwYCgREQWK7K0wOSqQ54hAeWRlI4Lqs3SOOVtLM9AhoraMgY4PA0MZ6BARkV87ojUi2GzvhsjQmk0G9BbTOgY6RNSWMdDxYWAomxEQEZFfO7JenW129ECEh25qeotpHQMdImrLGOh4PUeHGR0iIgqgjI6HQKezc42OjoEOEbVlDHS87rrG9tJEROTHbFYgU+u4tsnR3WOgExpsQsco7X1NMNAhoraMgY63pWvM6BARkT87ugOwlaPEEI50R6LH0rXq63TiwxnoEFHbxUDH29I1gxVlDHSIiMjP1+fsNvWEA0aPGR2RFle5Tic+koEOEbVdDHS8XqPDZgREROT/63O2G3qoc09d19xbTAtmdIioLWOg48PA0BKrDQ6Ho7W3iIiIqKbDWkZng627Oo8IqT/QieMaHSJqwxjo+DAwVGKc8gp7a28RERFRVbYKIHOTurjO2kWd1166pgU6UaFBCDbxMICI2i7PfwXJw8DQCnUu63Skaw0REZHfyNkFVJTCERKJbQWJdZauDUuLxdDOMRjZNb6FN5KIqGUx0PGy65o0IxDSeS22lTeJiIjIU9maLXEQHAValibC7PlDubAQE7677cQW3TwiotbAnLWXpWuhRi2jw4YERETkr40IyjoMVufBJgPMQaw+IKL2zedAZ9GiRTjrrLOQmpoKg8GAb7/9ts77L1y4UN2v+ikzMxOBVLoWisqMDhERkT+2li6KH1jn+hwiovbE50CnuLgYQ4cOxSuvvOLT43bs2IEjR464TomJWg1xwAwMNTCjQ0REfshuB45sVBePxwxQ57UNCyUiak98/kt4+umnq5OvJLCJjY0N4Dk6zOgQEZEfytkNWIuBoDDkhHYFcIwZHSKilmxGMGzYMJSXl2PQoEF46KGHMGHChFrvK/eTk66goECdW61WdfKV/piGPBYwIdg5R0cUlVoa+Dyto3H7Hrja634L7jv3vTmel/x/fQ6SB6PYqs16Y6BDRNQCgU5KSgpef/11jBo1SgUvb7/9NiZOnIgVK1ZgxIgRHh/z5JNP4uGHH65x/dy5cxEeXjnozFfz5s3z+TER5VmYIt8oh0V9vWzVGlj2Bd7Q0Ibse1vQXvdbcN/bp6be95KSkiZ9Pmq+9TlIHYbCMq3MmqVrREQtEOj07dtXnXTjx4/Hnj178Nxzz+Gjjz7y+Jj77rsPd911V5WMTlpaGqZNm4bo6OgGfSIpb/5Tp05FcLDkZ3xQcBjYeg/Mzjk6/QYOxoyRnREoGrXvAay97rfgvnPfm3Lf9Yw6+bGsLZUZnVLtvYoZHSKiVpqjc8IJJ2Dx4sW13m42m9WpOnnzbswbeIMeHxqhzoJQAQPsKLdpzxNoGvu9C1Ttdb8F95373lTPR36uLE87j0hEcb62jpSBDhFRK83RWb9+vSppCwgmrb20CEEFmxEQEZF/sRRr5+ZIlq4REbnx+S9hUVERdu/e7fp63759KnCJj49Hly5dVNnZoUOH8OGHH6rbn3/+eXTv3h0DBw5EWVmZWqOzYMECtd4mkAaG6p3XythemoiI/El5kXYeEoHicr10jcNCiYh8DnRWr16NSZMmub7W19JcffXVeP/999WMnPT0dNftFosFf/vb31TwI40EhgwZgl9//bXKc/g1U2XZBjM6RETkdyx6oBOFYmfQw4wOEVEDAh3pmOZw1N51TIIdd/fee686BSyDQRsaaitXLaYZ6BARkd+Q92NXoBOBonJtvU5kKAMdIqJWWaMTcJzla2aDFSUsXSMiIn9hLQUcdu2yORJFrtI1BjpERAx0vBGkNSSQjE4ZMzpERORvjQhEcOUanYgQBjpERAx0vCGla/oaHWZ0iIjIX1gKtfPgCMBorMzosHSNiIiBjleCtEDHDAvX6BARkV+2lhYsXSMiqsRAx4dAJ8QgXdectdBERER+1FpaFMtUa3ZdIyJSGOj4MDRUdV2zaJ+WERER+U1GJyQSdrsDxc73KGZ0iIgY6PjWdY3tpYmIyB/X6IREosRqU92mBQMdIiIGOj51XTOrZgQsXSMiIj8rXTNHujquGQ1AaDDf3omI+JfQl65rBraXJiIifyxdk2GhlWVrBhl2TUTUzjHQ8anrmla65tBrA4iIyC8dOnQIV1xxBRISEhAWFobBgwdj9erVrtvl7/iDDz6IlJQUdfuUKVOwa9cuBHLpWlEZ1+cQEbljoONL1zVYYbM7YLGxfI2IyF/l5uZiwoQJCA4Oxs8//4ytW7fimWeeQVxcnOs+Tz31FF588UW8/vrrWLFiBSIiIjB9+nSUlZUhUJsRuIaFMtAhIlL419DHgaGizGKHOcjUyhtFRESe/Oc//0FaWhree+8913Xdu3evks15/vnncf/99+Pss89W13344YdISkrCt99+i0suuQSBuEaHw0KJiKpiRseHjE6YwarO2XmNiMh/ff/99xg1ahQuvPBCJCYmYvjw4Xjrrbdct+/btw+ZmZmqXE0XExODMWPGYNmyZQjUjA6HhRIRVcW/hj4EOuEmGySpw0CHiMh/7d27F6+99hruuusu/POf/8SqVavw17/+FSEhIbj66qtVkCMkg+NOvtZvq668vFyddAUFBercarWqk6/0xzTkse5MZQXqE0ubKQwFJdr2hQUbG/28zamp9j0Qcd+57+2JtRn329vnZKDjw8BQFehIRsfCQIeIyF/Z7XaV0XniiSfU15LR2bx5s1qPI4FOQzz55JN4+OGHa1w/d+5chIeHN3hb582bh8YYd3g/EgGs374Ha0pT5A0LeUczMXv2bPi7xu57IOO+t0/tdd/nNcN+l5SUeHU/Bjo+DAwNN2plAaVW7ZyIiPyPdFIbMGBAlev69++Pr7/+Wl1OTk5W51lZWeq+Ovl62LBhHp/zvvvuUxki94yOrAOaNm0aoqOjG/RppLz5T506VTVNaCjT+y8BhcDQUePROaMXkL4PfXt2w4wZ/eCvmmrfAxH3nfvenvbd2oz7rWfV68NAx4eBoWF6oMOhoUREfks6ru3YsaPKdTt37kTXrl1djQkk2Jk/f74rsJE3Tem+9pe//MXjc5rNZnWqTt68G/MG3tjHw6qt0QkKj0FphTb6IDqskc/ZQhq97wGM+859b0+Cm2G/vX0+Bjo+dF0LNegZHZauERH5qzvvvBPjx49XpWsXXXQRVq5ciTfffFOdhAzTnDlzJh577DH07t1bBT4PPPAAUlNTcc455yCgWIpqNCNge2kiIg3/GvpQusaua0RE/m/06NGYNWuWKjd75JFHVCAj7aQvv/xy133uvfdeFBcX48Ybb0ReXh5OPPFEzJkzB6Gh2t/7gGwvXabVrEcx0CEiUvjX0IfSNbMzo1PGZgRERH7tzDPPVKfaSFZHgiA5BTT3gaEWrWadGR0iIg3n6PhQuqYHOiUWNiMgIqJWZrMCNmfL65AIlq4REVXDQMeHOTpm6KVrbEZARER+sj5Hz+g4Ax2WrhERaRjo+BDoBLsCHZauERGRn6zPkVlvQSEoKmNGh4jIHQMdH0rXQpyBThkDHSIi8qP1OYKla0REVTHQ8SWj43BmdNiMgIiI/Ki1tMPhQLHzvSkqlIEOEZFgoONDoBPkDHSK2YyAiIhaW3mhdm6ORJnVDptdGxjKjA4RkYaBjjek/lkFOhZ1ri/4JCIiav3StcqOayI82NR620RE5EcY6PgwMFQPdNzfUIiIiFq7dE3/AC7SHASj0dC620VE5CcY6PgwMNRk10rX9M42RERErR7omCPdGhEwm0NEpGOg40PXNaNdy+gUMqNDRET+0l46xD3Q4focIiIdAx0fSteMdisMsDOjQ0REftVemsNCiYhqYqDjQ+maCEEF1+gQEZEfrdGpbEbAjA4RUSUGOj6UrgkzrCix2FxtPImIiPxnjQ4DHSIiHQMdb5iCARhcgY7gLB0iIvKXNTosXSMiqomBjjcMBtfQ0HCT9mbCdTpEROQv7aX19yRmdIiIKjHQ8bF8LTZEK1njOh0iIvKLZgSqdM2mLjLQISKqxEDHW86MTpzZrs4LmdEhIqLWVF7oYWAo5+gQEekY6PgY6MQEaxkd/U2FiIiotdtL61UGkczoEBG5MNDxlklrMR0drGV0WLpGREStiu2liYjqxEDHx6GhMcFaHTSbERARkb+s0aksXWOgQ0SkY6Dj49DQyCDnGh1mdIiIqLXY7VW7rumBTigDHSIiHQMdH7uu6YEOMzpERNRqrCWVl90CHZauERFVYqDjYzOCSH2OTrk2OJSIiKjF6dkcgxEIDmPpGhGRBwx0fAx0IkzONTrOmQVEREQtrryybE2GWhc735MY6BARVWKg42PXtXBXoMPSNSIiaiVu63PKK2yw2LSyapauERFVYqDjY9e1cKOzdK2MpWtERNT6raX1bI6ICOHAUCIiHQMdH0vXwvRAhxkdIiLyo9bSYcEmBJn4tk5EpONfRB9L10IN2htKIbuuERFRaykv1M5DIl3vRyxbIyKqioGOj6VroQatZI0ZHSIiavWMTkgkii16xzWWrRERuWOg4+PAULMzo6OXChAREbXmGh0OCyUi8oyBjo8DQ0NQmdFxOBytvFFERNTe1+joA6wjQhjoEBG5Y6DjYzOCYIdFnVttDpRXaO08iYiIWmuNDoeFEhF5xkDHx0AnyFHZVprrdIiIqLXn6LB0jYjIMwY6PpauGW0W15wCvVyAiIio1UrXnIEOu64REVXFQMfHjA4qyl2fmjGjQ0REraLcfWAoS9eIiDxhoONroGMrd72ZMNAhIqLWLV2LQlG5TV2MYDMCIqIqGOj4ODAUFRZEhgariyxdIyKiVsH20kRE9WKg4+PAUFSUuYayMaNDREStvUansnSNA0OJiNwx0PFxYKh76VohAx0iImrlNTr5pVo30ChntQEREWkY6PjYdU2VrplZukZERP6xRieroExdTIp2vk8REZHCQKcBpWtRzjpovVyAiIioxTgcrkDHERKB7IJydTkp2vk+RURECgMdn0vXJKPDrmtERNRKKsoBu/b+k2czw2Kzq8uJUQx0iIjcMdDxuXStco5OIUvXiIiotRoRADhSojUgSIgIQUgQ39KJiNzxr2IDBobq06eLyrUFoERERC3GUqidB4Uhq0h7H2LZGhFRTQx0GjAwNIqla0RE5AetpfVGBMkxDHSIiKpjoONr6Zq9ApHBBnWRXdeIiKg1W0tnsuMaEVGtGOj4mtEBEB2iLfxkRoeIiPyjtTQzOkRE1THQaUCgExlkU+cMdIiIqPUCnQhksbU0EVHTBTqLFi3CWWedhdTUVBgMBnz77bf1PmbhwoUYMWIEzGYzevXqhffffx8BxyjrcrSStSiTM6PD0jUiImqt0jVzJDLznWt0GOgQETU+0CkuLsbQoUPxyiuveHX/ffv24YwzzsCkSZOwfv16zJw5E3/+85/xyy+/IKAYDK6hoRFBWoBTbLHBZne08oYREVG7bEYQUtmMgBkdIqKatPZhPjj99NPVyVuvv/46unfvjmeeeUZ93b9/fyxevBjPPfccpk+fjoAbGlpRigiTVromii0ViA4NbtXNIiKi9tde2hYcgZxii7rMZgRERK2wRmfZsmWYMmVKleskwJHrA7XzWgisCDZpZWzFXKdDREStkNEpMWhZnBCTEfERIa28UUREbSCj46vMzEwkJSVVuU6+LigoQGlpKcLCwmo8pry8XJ10cl9htVrVyVf6YxryWHdBQWa1SsdWVoJIcxByS6zILSpDh/Bm/zY2WFPte6Bpr/stuO/c9+Z4XvK/NTpFdi3QSYw2qzWzRERUlV8eoT/55JN4+OGHa1w/d+5chIeHN/h5582b16jtmlxmRaRkqZb8DqNtgGpOMO+3RdgVBb/X2H0PVO11vwX3vX1q6n0vKSlp0uejpsvo5Nu1KgOuzyEiaqVAJzk5GVlZWVWuk6+jo6M9ZnPEfffdh7vuuqtKRictLQ3Tpk1Tj2vIJ5Ly5j916lQEBzd8PU3QoX8D2ZkYN3oEOmYHIyerCINHnoCTenWAv2qqfQ807XW/Bfed+96U+65n1Mn/1ujkWrVyNXZcIyJqpUBn3LhxmD17dpXr5M1Yrq+NtKGWU3Xy5t2YN/DGPl7vuhbkqEBUmJZZkg7TgXBA1eh9D1Dtdb8F95373lTPR/6Z0cmxaj8bZnSIiJqoGUFRUZFqEy0nvX20XE5PT3dlY6666irX/W+++Wbs3bsX9957L7Zv345XX30VX3zxBe68804E7NBQW7laoyM4S4eIiFpjjU52uR7osOMaEVGTBDqrV6/G8OHD1UlIiZlcfvDBB9XXR44ccQU9QlpL//TTTyqLI/N3pM3022+/HXitpYXJ2dWmwoJIZ0vpInZdIyKilmTRAp3MUpM6T45hRoeIqElK1yZOnAiHo/Yhme+//77Hx6xbtw4Bz1m6hoqyyowOAx0iImqFQOdwqfY+xNI1IqJWmqPTpsjAUGErR1QoAx0iImq90rWMYu0tnIEOEZFnDHQaMDBUStciQrRAp5BrdIiIqFWaEWgfvnGNDhGRZwx0GlK6Js0ImNEhIqKWZqsAKkrVxWKHWVUXhDs/eCMioqoY6DSkdK2iHFGurmucGk5ERC3EqmVzRDHCOEOHiKgODHQaVLpWmdEpLre17jYREVG7W59jNwTBgiB2XCMiqgMDnQbN0bG4uq4VsnSNiIhaeH2OxSRDqw1IjGKgQ0RUGwY6DQl0KsoQ4WovzdI1IiJqIZZCdVZmCFPnyTFsREBEVBsGOr4I1t5YUFZQ2V66nq5rB3KKsWr/8ZbYOiIiaielayXQMjlco0NEVDsGOr7o2F87P7KhysDQugaoXvv+Klz0xjIcztO65BARUcv697//DYPBgJkzZ7quKysrw6233oqEhARERkbi/PPPR1ZWFgKldK3QoQU4iQx0iIhqxUDHF51HaefHdiAS2puN1eZAeYXd493LK2zYe7QYEgcdyClpyS0lIiIAq1atwhtvvIEhQ4ZUuf7OO+/EDz/8gC+//BK///47Dh8+jPPOOw9+z6JldApsWskaMzpERLVjoOOLiA5AXHft4tENrquLa2lIkJVf7rqcU1x5mYiIml9RUREuv/xyvPXWW4iLi3Ndn5+fj3feeQfPPvssTj31VIwcORLvvfceli5diuXLlyMQAp1cmzbugF3XiIhqxyljvuo8GsjdB9Oh1YgIGYpii02VryVE1lwQesitXO1YIQMdIqKWJKVpZ5xxBqZMmYLHHnvMdf2aNWtgtVrV9bp+/fqhS5cuWLZsGcaOHVvjucrLy9VJV1BQoM7leeTkK/0xvj7WWJoPkwRxjlAYDUB0iKFBr9+aGrrvbQH3nfvenlibcb+9fU4GOg0JdDZ9ARxchQjzSBXoFNbSkMB9XU5OsaUFN5KIqH377LPPsHbtWlW6Vl1mZiZCQkIQGxtb5fqkpCR1mydPPvkkHn744RrXz507F+Hh0uq5YebNm+fT/fseWY9+UkngCEVUkANzf5mDQOXrvrcl3Pf2qb3u+7xm2O+SEu+WhDDQaeg6nYOrEGm+FdmFWkOC+gKdY0XM6BARtYSMjAzccccd6s01NLRpSrvuu+8+3HXXXVUyOmlpaZg2bRqio6Mb9GmkbN/UqVMRHBzs9eOMvy4DMoFihKFrYgxmzKiZffJ3Dd33toD7zn1vT/tubcb91rPq9WGg46ukQUBQKFCWh75x2diLyFpbTB/Odw90mNEhImoJUpqWnZ2NESNGuK6z2WxYtGgRXn75Zfzyyy+wWCzIy8urktWRrmvJycken9NsNqtTdfLm3Zg3cJ8fX6G9rxQ7zEiKCQvog6bGfu8CGfed+96eBDfDfnv7fGxG4KugECBlmLo4BDvVebGltoxOmetyDjM6REQtYvLkydi0aRPWr1/vOo0aNUo1JtAvy5vk/PnzXY/ZsWMH0tPTMW7cOATCHB3J6LDjGhFR3ZjRaWj5WsZy9LdJoDPCqzU6zOgQEbWMqKgoDBo0qMp1ERERamaOfv3111+vStHi4+NV6dntt9+ughxPjQj8setaMUKRFl0zw0RERJUY6DS0IQGAXpZt6tzTGh0ZIlqlGQEzOkREfuO5556D0WhUg0Klm9r06dPx6quvIlAGhkozgiRmdIiI6sRApxGBTkrZXoShzOManYLSCtWRTSeXSy02hIVIY1AiImpJCxcurPK1NCl45ZVX1CmglBe6MjqcoUNEVDeu0WmImE5AVCpMsGGwYZ/HjI4+Qyc+IgTmIO3bzM5rRETUKMzoEBF5jYFOI9tMDzfu9rhG54iz41qn2DB0cA4TZaBDRESN4XA1I2CgQ0RUHwY6jSxfk0Cn2ENGR1+fkxobioTIEHU5hw0JiIioERzOZgS2oAhEh7L6nIioLgx0GhnojDDuQlGZtcbNh5ytpVNimNEhIqIm4HDAYNVK18IjY2AwGFp7i4iI/Bo/DmqolKGwG4KQiDyYS4/UmtGR0jU945NTzIwOERE1kLUUBoddXYyMrhx0SkREnjGj01Ah4SiJ66cudi3ZUkfpWhg6RDGjQ0REjeQsW7M7DIiPjWntrSEi8nsMdBqhPHlklXk67o7kl1Wu0YnQ1uhwaCgRETW2tXQJzEiMCW/trSEi8nsMdBrB3knrvNbftrPK9RU2OzILylylax2dGR0ODSUioka3lmbHNSIirzDQaQRTF60hwQDsg92iBTYiu7AcNrsDwSaDakSQEMHSNSIiaprSNZmhk8xAh4ioXgx0GiE8qTdyHFEwG6woPbihxvocmVptNBrQIYrtpYmIqCkzOtoHaEREVDsGOo1gDjZhg6O3ulyRvtJ1/SG9EUFMmDrXMzrHSyyqrI2IiMhXDucanWKEsXSNiMgLDHQaQWYYbDX1UZeNB1fVaEQg63NEXHgwZNyBwwHkltScuUNERFSfkqJ8V+laIjM6RET1YqDTSLuC+6vzkMy1HltLiyCTEfHheuc1rtMhIiLfFRbkqXNrUDjMQabW3hwiIr/HQKeRMsL6qZkG5qIMoCi7SqCTEltZWpAQyXU6RETU+IyOIziitTeFiCggMNBpJFNYNHY6OmtfHFytzg7llVXJ6AjpviZyipnRISIi35UXa4GOwRzV2ptCRBQQGOg0UqQ5COvsvbQvnOt09IyOvkZHJDgDnaOFDHSIiMh31hKtGUFwWGRrbwoRUUBgoNNIERLoOCoDneLyCuSXag0HUmIqS9c66KVrxSxdIyIi31WU6YFOTGtvChFRQGCg00hRoUFYY9c6ryFjJTKPaut0okODEBUaXKN07RgzOkRE1ACOcm1gaGhEdGtvChFRQGCg0wSla3scqcgJ7QLYylG+dU6N9TmCGR0iImoMg1UbGBoRzYwOEZE3GOg0UqRZsjYGbIw+RX0dtedHj4GOPjSU7aWJiKghgpyBTlR0XGtvChFRQGCg00iRoUHqfGXYyeo8+ehihKMMqW6tpUWHKGfXNbaXJiIiH1XY7Aixa41uYmJiW3tziIgCAgOdRoo0a0PbdqAbEN8DwfZynGpc5yGjo5WuHS0qh8PhaJVtJSKiwFRQVoFIgxboREQx0CEi8gYDnSYpXQOKym3AgHPU5RmmFVVaS7s3I7BU2FFUXtEKW0pERIFKunlKtYAICuUcHSIibzDQaaLStUIJXgacrS5PMq5Hp/CqWZuwEBMiQrTsD8vXiIjIFwWlVkQ4Ax2YOUeHiMgbDHSaoOuaKCq3wp40BOmORIQZLOieu7jGffWhoWxIQEREvigoKobZ4KwGCIlo7c0hIgoIDHSaYI6OKC634ViJBT/Zxqiv4/b/XOO+eovpY8zoEBGRD0oLjqpzu7xtm9lemojIGwx0miqjU1aBI3llrkDHuHsuYCmpcl9mdIiIqCEshcfUebExCjDyrZuIyBv8a9lIEc5Ax2KzY39OMTY7uiPLlAxYS4Bdcz02JOAaHSIi8kVFUY46Lw1iNoeIyFsMdJoooyN2ZBZWGR6Krd/WUrrGjA4REXnPXqxldMqDGegQEXmLgU4jmYwGhDu7qe3MkkAHOJQyXbtxZ9XyNVdGp5iBDhER+aAkV51ZzXGtvSVERAGDgU4TZnV2ZhWpc0OnEUBsF8BaDOz+1XW/BD2jU8jSNSIi8p6pTAt0bKEMdIiIvMVApwln6WTkatmb1Lhw10wd9/K1hAhnMwJmdIiIyAdB5XnahfD41t4UIqKAwUCnCUQ5MzoO54zQ1NhQYMA52hc75gDWUnWxY5SW0WEzAiIi8kWoVcvoGBnoEBF5jYFOE3Ze06XGhAGdRgIxac7ytflVMjr5pVZYKuytsq1ERBR4wiry1bkpskNrbwoRUcBgoNPEndfCgk2IDQ8GDIYa5WsxYcEIMhrU5ePFzOoQEZF3ImwF6jwkioEOEZG3GOg04RodvWzNIEGOcC9fsxTDaDQgPoItpomIyHsOhwPRdi3QCYvp2NqbQ0QUMBjoNOEaHZEaG1Z5g5SvxXaVkdbAz3+v0mKagQ4REXmjqLwCsQatq2d4LAMdIiJvMdBp4oxOJ/dAx2gE/vSSGiKKdR8BG7+obDHNhgREROSF/OIyxKBYXTZHJ7b25hARBQwGOk3cjCBFGhG463EKcIqWzcEPMzEgOEtdzGFGh4iIvFCcfxxGg7OtZxjn6BAReYuBTpOXroXWvMMp9wLdTlId2K478jDMsCCHzQiIiMgLJXnZ6rwI4YApuLU3h4goYDDQac7SNZ3RBJz/NhDeAUmlu/FA0Ec4VsiMDhER1c9SeFSdFxmjW3tTiIgCCgOdJhBpDvbcjMBdVDJw3ptwwIArguajR/a8lttAIiIKWJaiHHVeEhTT2ptCRBRQGOg08Ryd5BgPpWu6XpNxYMDN6uJ1Oc8AOXtaYvOIiCiA2Z2BTlkwAx0iIl8w0GkC+myc5OhQhAab6rxv0bh7sMLeD+EoBb66FqhgCRsREdWhRAt0rCGxrb0lREQBhYFOE+iTFIn7Tu+Hf58/uN77JkSH4w7LrTjuiASObACWv9Yi20hERIHJWHZcnVeY41t7U4iIAgoDnSZgMBhw0yk9MbFv/fMNEiLMyEQCnqy4TLti1duAraL5N5KIiAKSqSxPnTvYWpqIyCcMdFpYSJAR0aFB+N42HhVhCUB+BrBjdmtvFhER+SmzVQt0DOEJrb0pREQBhYFOK+gQZUY5QpDZ61LtihVvuG4rr7DhrUV7sTOrsPU2kIiI/EaoM9AxRbJ0jYjIFwx0WkGHCLM63975QsAYBBxYDGRuUte9vnAvHp+9Df+apX1NRETtW7itQJ0HR3Vo7U0hIgooDHRaQYcorUvbIVss0P9P2pUr3kBhmRXvLtmnvlyXnoficq7dISJq76LsWqATGt2xtTeFiKjtBzqvvPIKunXrhtDQUIwZMwYrV66s9b7vv/++WqzvfpLHtWfSkEDkFJUDY7S5Otj0Jb5ctB75pVb1ZYXdgTUHcltzM4mIqLU5HIhxaKXMYTEMdIiImjXQ+fzzz3HXXXfh//7v/7B27VoMHToU06dPR3Z2dq2PiY6OxpEjR1ynAwcOoD1LiNQyOkeLLEDaCUDKMKCiDEXL3lPXd4zSAqFle7XZCdQyNh7Mw8HcktbeDCIil7LiPAQbbOpyZHz9nT2JiKgRgc6zzz6LG264Addeey0GDBiA119/HeHh4Xj33XdrfYxkcZKTk12npKQktGcdIt0yOgaDK6tzgf1n9Ig34+5pfdTXyxnotJisgjKc++pSXPlO7dlJIqKWVpSnfYhY6ghBZER0a28OEVFACfLlzhaLBWvWrMF9993nus5oNGLKlClYtmxZrY8rKipC165dYbfbMWLECDzxxBMYOHBgrfcvLy9XJ11BgVafbLVa1clX+mMa8tjmEBtqUudHC8vUNpX1mAELYpBqOI6H++xFWrcT1O0bD+Yjr6gUEWaffkx+ve8txdf93nY4Dza7A/uOFSO3qBSRjfiet7b2+jMX3Pem3/f2+L30J6V5R9V5viEKyUZDa28OEVFA8elo7tixY7DZbDUyMvL19u3bPT6mb9++KtszZMgQ5Ofn4+mnn8b48eOxZcsWdO7c2eNjnnzySTz88MM1rp87d67KHjXUvHnz4A/2qrgtCBnZeZg9ezZ+P2JA14pTcUfQLPTb9TaWGpKQYDYhpxx4/at56B/naPRr+su+tzRv93t5thxAaAHoJ9/PRecIBLz2+jMX3PemU1LCcs7WVJavBTqFEui09sYQEQWYZv/Yety4ceqkkyCnf//+eOONN/Doo496fIxkjGQdkHtGJy0tDdOmTVPrfRryiaS8+U+dOhXBwcFobftzivHCliUodQRh8rSpeOK5P7C4YgpuD/4BHYt3YMaIzlhUbsTXaw/D3rEnZjhL2RrC3/a9pfi633sW7AH27FGX0/qPwOmDAveQor3+zAX3ven3Xc+oU+uwFh5T5yWmmNbeFCKith3odOjQASaTCVlZWVWul69l7Y035A14+PDh2L17d633MZvN6uTpsY15A2/s45tKcqyWLii22PDZ6kPIKihHcnQKHL3PBrZ8jeA172JCr/tUoLNif16TbLO/7HtL83a/MwsrSyUP5pe3ie9Ve/2ZC+570+17e/0++ouKIm2tZmkwAx0iomZtRhASEoKRI0di/vz5rutk3Y187Z61qYuUvm3atAkpKSlor2T9R0iQ9q1/Yf4udX7zKT1gGvsX7Q6bvsT4ZK1cbfOhfDVfh5rX4bwy1+UDx1iqQ0T+wVGiBTqWkNjW3hQiorbfdU1Kyt566y188MEH2LZtG/7yl7+guLhYdWETV111VZVmBY888ohaW7N3717VjvqKK65Q7aX//Oc/o72SLnQdnZ3XCssqVBe2S07oAnQeBaSOAGzlSN7yFrrGh6kF8qv3c55OczucV1qltJCIyB8YSrW//9aQuNbeFCKitr9G5+KLL8bRo0fx4IMPIjMzE8OGDcOcOXNcDQrS09NVJzZdbm6uakct942Li1MZoaVLl6rW1O19ls4h58G1ZHNCg7WF8Bh3K/D19cCSF/BM7A5cgYtVm+lJ/Tg/obk4HA7Xz0IcyGFGh4j8g6lMC3QcYQx0iIhapBnBbbfdpk6eLFy4sMrXzz33nDqR51k68REhuGxMl8obBp0P5KUDCx7FqLw5+DZkC17YeT8wo3/rbWwbd7zYgvIKu+vrzIIylFpsCAtxBp9ERK0k2JKnzh3hCa29KUREbb90jZpGv+QodX7LxJ4ID3GLN2WA6El3AVf/AFt4IvoZM/Df3DtQsu6L1tvYdrI+p2OUGdGh2s8i/TizOkTU+kKtWqBjjIhv7U0hIgo4DHRayV8n98a3t07A9Sd293yHbifC9JfFWGcahEhDGcK/uwH46W6gorI7GDUNvWytU2wYunXQOuJxnQ4R+YNwW746D47s0NqbQkQUcBjotBJZkzMsLVY1JqhVVBK+GvASXq44W/t61VvAmxOBrd9Ju7sW29b20ohAAp2uCVqgc4CBDhH5gUibNsfIHNOxtTeFiCjgMNDxcyf0TMLTFRfj/6IeAmQxavZW4IurgNfGARu/BOy2OjMV983aguzKdfZUR6CTGhuKbgnh6vJ+NiQgotZmLUUotCx+aDQzOkREvmKg4+fG9tAWoH54rA8KblgBnHyvfLQHHN0OfPNn4OXRwLqPAVvNWTtP/7IDX609hLmH+GOuy+F8PdBhRoeI/EjJcXVmdZgQFc01OkREvuIRsJ9Lig5Fjw4RcDiAlZkATv0XMHMjMOl+LcNzfA/w3S3Ay6OA9OWux5VZbZi3NUtdTi+qozyOcMjZjEACHVdGh0NDiQLWk08+idGjRyMqKgqJiYk455xzsGPHjir3KSsrw6233oqEhARERkbi/PPPR1aW9jfTX9iKtWGheYhATHhIa28OEVHAYaATAMb21LI6y/Zqb3oIiwVOuQeYuRmY+ggQ0RHI3Q+8NwNY8qIMhsHCHUdRVF6h7p5VakBhWc2MD9W+RkeyPOUVtZcFEpH/+v3331UQs3z5csybNw9WqxXTpk1Tw611d955J3744Qd8+eWX6v6HDx/GeeedB39Smn9Unec6ohAdFtzam0NE1D7m6FDLl699siJdDQ6twhwJTLgDGHUd8MNMYPNXwLwHgANLscB2c5W7bjpUgFP6adkKqiTBzNHCcldGJy48GBEhJhRbbMg4XopeiZGtvYlE5CMZYu3u/fffV5mdNWvW4OSTT0Z+fj7eeecdfPLJJzj11FPVfd577z30799fBUdjx46FPyjNz4b8BSowRCHYxM8liYh8xUAnAIztodVmbz1SgLwSC2KrlzCYo4Dz3wa6TQB+/juw82fc4ViNHYbbURA/BPtySrDxYD5O6ZfcOjvgxzLztbK10GCjCnKkC55kdeR7Let0GOgQBT4JbER8vPa3VAIeyfJMmTLFdZ9+/fqhS5cuWLZsmcdAp7y8XJ10BQVaNzR5Hjn5Sn9MXY8ty8tW50XG6Aa9hr/yZt/bKu479709sTbjfnv7nAx0AkBiVCh6dozAnqPFWLnvOKYN9BCwSJtqyeykjkDxx1egU3EGvjI/ghUpM3F1zlBsOKi90ddJFgLlpQNBZiAquV3N0JFsjt7qu1uHcBXosPMaUeCz2+2YOXMmJkyYgEGDBqnrMjMzERISgtjY2Cr3TUpKUrfVtu7n4YcfrnH93LlzER7e8Gy5lNbVJn7fBqRJUOUIx+zZs9HW1LXvbR33vX1qr/s+rxn2u6TEu2M0BjoBYlzPBBXoyDodj4GOLnUY/tXxFUwveBSnm1bhxN1PY7M5BHv2d4Hjh5NgSBkCJA8FkgYApbnA4XXAobXauZxKjwMGIzDkYuCUe4H4HmjLDjsbEcj6HF03dl4jajNkrc7mzZuxePHiRj3Pfffdh7vuuqtKRictLU2t/YmOjm7Qp5Hy5j916lQEB3tef5P+6TzpRABbeEecOWMG2gpv9r2t4r5z39vTvlubcb/1rHp9GOgE0Dqd/y2XdTpau9HaSAOCn3eX4NuKmVh24k4kr30OYeUFGITdwJrdbveU7IWj5hMYgwB7BbDhU2DTl8Cwy4GT7wFi5XPFwPHHrmP4YKcRJ06yIqGO/1yuGToxNQMdZnSIAtttt92GH3/8EYsWLULnzp1d1ycnJ8NisSAvL69KVke6rsltnpjNZnWqTt68G/MGXtfjjWW56rzCHNcmD44a+70LZNx37nt7EtwM++3t83F1YwAFOkYDsO1IQc2mBG5+3ZqF8go7enSIRPK0O1Hxt924xPA0brPcjr19bwB6ngqESxc3h5a5SRwIDLsCOOMZ4IYFwD8Pa+e9pmgBz9oPgJdGALPvAQo9l3T4o2d/3Y21OUZ8u+FInffTA52U2FDXdV2dLaaZ0SEKTA6HQwU5s2bNwoIFC9C9e/cqt48cOVK9Sc6fP991nbSfTk9Px7hx4+AvTM5AxxZatcSOiIi8w4xOgOgQacYlJ3RR3dce/G4zfvrrSR678Py48bA6P3NIirbmxGCEMSoZP5amonNsT/zj9H7aWpyibK1rW4iWvaii00jgiq+1uTwLHgP2/wGsfBNY9Q4Q3QmI6Vz1FNsF6Dre83P54Nt1h3DPVxvwymUj6i7Pq4fMENqeWaguy1qbuhx2NiOQNTq6bh20/TiYWwqrzc5uR0QBWK4mHdW+++47NUtHX3cTExODsLAwdX799derUjRpUCClZ7fffrsKcvyl45oIKs/TLoRzWCgRUUMw0Akg907vizmbM7EzqwjvLdmHG0/uWeX2/FIrft+pzV04c2iq6/oukQ4szQY2ZDjfNCUAikqq/wW7jAWu+RHY+zvw2+NAxgogP107VRfeAThxJjDqeiCknoW5BYcBSzHQoXeVT2BfmL8LVpsDHy0/0KhAR7JeFXatLG/bES3g8WaGji4xyqy6sJVZ7TiUW+oKfIgoMLz22mvqfOLEiVWulxbS11xzjbr83HPPwWg0qkGh0k1t+vTpePXVV+FPzFYto2OQv69EROQzBjoBRNpK/+O0frj36414/tddOGtoKlLc1pbM3ZKpAoU+SZHokxTlur5rpHbQv+lQPmx2B0xSA+eLHqfgm7ye+KF4LZ6YFIMUwzEg/2Dl6chGoOAgMPd+bWDpiXcCo64Fgiu3DSXHga3fAZu+Ag4s0UrnpDxu2mNAYn+19mjfMa1UTErzZMBpVKgX9ZfWMsBhrxJcSStt3a7sIlgq7AgJqpmVkeDKtUbHLdCRTJis05Gs0P6cYgY6RAFG/m/XJzQ0FK+88oo6+auwCu1vWVCkNjSaiIh8w0AnwFwwsjM+W5WOtel5eOynbarMS/fjRm09yplDKrM5IjkcCA8xqUYFe44WVQmCvLHlcD7+8fUmWGwmvHOgI+4/85Sqd7BZgY2fA7//R2tP/ct9wJIXgJP+ppVcSHCz+1fA7tbz3GDSrtuzABhxNX7MO8t1kwRri3cdw+mDU2rfKAmwlr8GrP1Qa4d99Q8qYBKuzJXzuXZnF2FAas2uSJIBK7HY1OWUmMo1Ovo6HQl0DrAhARG1BlsFwu3ahz8hUczoEBE1BBcfBBij0YBHzxmkGhP8tPGICghEbrEFS3Yfc63PqfIYAzDQeaC/3i0I8EapxYa/froOFptdfb1ghzbArgpTMDD8CuC2NcBZLwAxaUBRJvDzPcDX16sBpirISR4MTH0EmLkZuG0V0O9MLRuz5j3ct/ty3GL6Did31wZ0/rrNw+uIw+uBr/8MvDAUWPYyUF4AFB8FPjoXyN2v7rLhoLaPQQaHK1Cra4ZOh8gQhAabqtxW2XmNDQmayi9bMlWgTURekPb/TmHRzOgQETUEMzoBaGBqDK4a1w3vL92vGhP8PPMkzNmSqdalDEiJRo+OWrDgbmjnGKzan6uyHReN8r5V9OOzt6r5PR2jzCqY2nu0WHUj6+oMBKoICgFGXgMMvQxY9xGwzFkSMug8YNAFQGK/qve/5GNg/xIc/fpudCzcinuDP0d5/u9YHJyC0m3RsP88EMaIeCAsXsvabPhMa4yg63YSMPrPwMJ/A0e3AR+eg8LLf8BeZwnc0AQH1hwz1NqQQJ+h4162ptP3r6UyOp+vSsesdYfw8mUjVOOJtkaC8Js+WoO+SVH45c6TW3tziPxfidZdM88RgeiImn+jiIiofgx0AtRd0/rgp01H1EH923/sw9I9zmzOUM/lXkM6RVfJdnhj3tYsNbtHPHvRULzy2261lmbB9mxcO6Fqu9YaAc/o67VTPRxdx+MS++MYZJmHJ6K/QURJJiabMrURPyt+r/kAKXmTwGncbWo4qpI2Bnh3OpC7D8b/nY9ox98QGdsB/WKLseaYZHQKvJ6ho+vmbDHdUhmd1xbuUXN7pPPcn09qe0Naf96slVXuyCpEdkEZEqOrlgoSUTUyvFmy9Y5IxIS1v7kbRE3FZrOpwZWtSV4/KCgIZWVlanvaC2sj9ltGAJhMVattGoKBToCKDg3Gv2b0x8zP1+OlBbvUgntx5uCq63PcMzpi+5FC1X65eqlWdXIw+vevN6rLN5zUHSf17uic4XMcv+04Wneg44MV+45jT04pMkNOweO3/RM4tASfLFiF9IMHMalLEMZI87XSPKAsH0gdDoy5SWtpXeWbkQJc9S3w7mmIyNuB90Kewvspz6NTsFYmte1wgVqcrNptu/HUiEDX1dmAION4CWwluTDZLN51qmuAgjKrazjp0j05bS7Qke/9ArdSxOX7juNPbl0BiagmR0mOGuuchygkh/Gtmqgh7z3SWl4GA/vDtsgw4oyMjBrHIm2Zo5H7LQOd5fGN+Z7xr2cAO3tYqmpMIMGHGJoWiy7OTER1stheSqKOFZWrDMfIrnG1Pq/d7sDfvtyA48UWVQp39/S+6vpT+yXiidnbVVe0EksFwkMa/+sjc4HEn4Z1QmRkFND3NISXDMbrn6/HwtIozDnbyzKn+B7AlbNQ/MZ0jMBudMx7FGs634hgUzAKyyuQcby08nsjndqCzK41Oqluw0IVhwMpZftwa/APONmwDsb/7gIcNqD7yVr77H5naOuSmogEYroVe3Pa3OweKR3U5xXp+9jYQEcaTKTFh8Ec1PhPe4j8kaUwB2ZnRqcvMzpEPtODnMTERISHh7dqgGG321FUVITIyEjV1r69sDdwvyVAKikpQXa29iFpSkodzanqwUAngMl/2kfPHoTTX/hDrc85q1oTgur3HZYWoxb5S0OCugKdd5fswx+7jqlZMi9eOsx1MNmzYyQ6x4WpQZpLdudg6oDGZTgkkJK5QOKyE7q4rp/Yt6NqgS1dzw7mlqBzXD1zeXRJAzHT9E88b3sIabkrEFJRiieiesNUnIWIz14E7DlAYaYcQQBBYfinIw6XBseh6+7egKWXlhnK3g7s/AXG/HTcox9Dq54GBmDfIu0UmQyMuEpbjxTTqfL17XatMYK02pbXiegIdOgDhNU91XyzW6BTbLFh40H5+bSdAYHzndmc6NAgFJRVqEC5MX7dmoU/f7gafz6xO+4/c0ATbSWRfykvyFaBTp4hCmH1ZOCJqCopk9KDnISEBL844LdYLKqtfXsLdCwN3G8Z7iwk2JGfY0PL2BjoBLjeSVF45OxBmL8tCxeOrLvJwNDOsSrQcW+/XJ10KHtqzg51+f4zBqBXYlSVYEmyOh8uO6DW6TQ20Plm7UHVzW1Qp2gMdpbW6fOCJBBbue+4Oki+enw3r54vu7AM8wq74ibjXfgo7BkkFW7EhdgIyP8NbY5qpYpSpKIUqabDwIEtwIFqt5vM2BQyFF8UDMCIyRfj3BGdgTXva+2spaPcoqeAP57WsjzSXlvaXcsgVPcW2rrIJC3g6dgX6NAXiOsGRHRwnjrW6Aq3fMchjIzM1YKlwiPaDKLkQUCnUdr6pwDz67YsdX7LpF7498/bVXOLo4XlqsFFY55POgAy0KG2ylqofSBQYoppV6UuRE1BX5MjmRwKXPrPT36eDHTascvGdFGn+khpW10NCWTtzh2frVfBhwQxl3t4zknOQGfhjmyP6168JY/9ZKVWtnapWzZHN7lfohbobPc+0NmYoQUMWR3GwfanL3B49tMojEjD93uBDildccMZE4CoFBVgWItycOVzs5CCHDx6ajwiy5xBhQQlfaarAObbuQfw0eJ9CC2NxbmxXYDJDwKn/APY/iOw+l2tA9zehdW2wgBEJWunomyg4BBQlKWd3DvGuXkcoZgZEgWTOQyRlmOIWVoCLPVwx+AIoOt4oMdE7ZQ4QPqNu39TgYpyoDgXQTatLK+1ZRWUuQa4njeik2q2IJk6+dmeUUcGsso+VfsdW5uutd2VDoAyC4kLtaktshVrgU55cOWHQETkG35IENia4ufHQKcdkYyO3jJZWkXHRVTNDvxnzna19kE+af/P+UM8/oKN65GgStqO5JepA9b+KTUHcXpDDnTlQFUGmZ49zK38y2ly/yQ8+fN2LN+TowadRprr/1WVki8xpHMsHF0HYF3XAiQNHIc3dq1CckEobpDsi1NmqRnL7QMQYjLimVNP04YN1dp5za3FtGRUVLvs84CjO4C9v2tDUaM7aWVsEki5r98pKwCO7QKO7dDuLycJfoqPASXHAJsFYShDF2MZIB9AOTfDERwOgzyXnMyRwMHV2v13z9NOIlzLCMFSBJQXauf2Csirz5AnynwJ6DoO6DIW6DKuapldC5HMnx5kJ0aFYmyPBPV7s2JfTt2BjswQ+elvwI45wOjrgJPuViWA0rhhV3blLJ5NB/NxYm8OU6Q2SDK5EuiE1F5mTEREdWOg047EhAejR4cI1ZJasjoT+yZWmXPy3hJt4OZTFwxBfLUgSCfd2ib07KAyLXIQ29BAR8/mSEMFT0FMz44R6JoQroIyGYp62iBpv1a3Dc7MwdC0yk9A+yZHqYRAZkEZcorKkeCcUaN3XEuJlbpRz58YVM7SqaXFtJSiyakuodFA55HaqTqHAxv3ZuD2t+ehR1gJ3r18MC77bD+2FIbjlcsm4qQ+iVXX/2Rv0QIrySIdWKoFPnLywCALi7I3a6dVb2lXxnQBuowBUkdorbmTh2hBVFOy27T5HzL7yBSk1tOIKf20fRnTPV7Nf1rhbKDh0YFlwDc3APkZ2tdLXwLWfQxM/Ac2xJylkjw6+T1moAOUV9hUYw+rfyTyqAkYne2lbaEMdIioYbp164aZM2eqU3vFQKedkU/WVaCTke8KdKT85+4vN6jLUq42yS0A8kTK1yTQ+W17Nm6d1MvnbZBs0s+bMmstWxOSTZrcL0k1RpD1R/UFOlIKp5fk6ZkrIUFUt4QI7DtWrLp/SZtscTi/9hk6OnmckGBLOtHVFhA1mMGATcccOOBIRtfOHWHoeQJSeq/HsrWHsHTv8aqBjpSoJQ/WTuNvAyoswJH1UEe2EqyERDnPI2A1mDH/h88xpW8Ugg6tAtKXAUc2AvnpwCY5falvgLZ2SNp2pwwBTCGVmSFLMVAu54VwGINhkPVEKoOU4DzvoM00ytntPO0CcvZoJ1s5YDDCHpWKm/MjcUZwB5xcPAJY0wvj4gap7g4yT0eaUVQJqG0VwKL/auufHHYgrjsw4Q5gxevA0e3Az/diYNjLmGq8AL9hFKSjumu9mTy24BAMx/cjqjRDC7hUbqv5PmlXmTw/8diP2/DR8gPoHmXCta29MdQkgsq1322HfGhARO3GxIkTMWzYMDz//PONfq5Vq1YhIsLDgPd2hIFOOyPzdGatO1Rlnc7/fbdZlaJJqda/zuhf73NIoKOvlfBUAlefr92aEEiZWW2m9E9Ugc5vO7LrDTSkfXReiRXBJgP6pURpB8pO0iJbBTqH3QKdvLJaZ+jopO10kNGA8go7sgrLkFJHUNRQmw9pHdcGpmqZMcmWfSOBzm7PmZoqJXRpJ3i+zWpFeXAsHP1mAIPP066ToOXQaiBjJXB4PXB4HVB4WCupk9PGz2p9qQaFdw47jAUHMdoAjJb1g2sXA2sB+WmvDOuAedah2LckD/ETz1HBGfLSga9vADKWa48feikw47+AOQoYfiWw9gPgtycQX5KOt0Kexa6wodhUFIUe+3KAZwu1fXHY1R+0U+Xln/030Hm0NkxWvk/SyEGya5IZk4yTWjeVqa2jkuBOsludRtbe7EECyu0/ARs+BfYsUIEchlwCnHgn0MH3YL8p/bIlUwU5Yn8hcLyoHEmmY1ogfGSD9vOW/b3xt1bdTvJNiFX7G20IZ0aHiKp+sCtd5WQQZ306dtSOedozBjrtjN6QQFpMy3+WnzYdwbfrD6slKs9ePMyr2TidYsPQNylKfSq/aNdRj2tsaiPtot9YtLfObI5uVLd4RJmDcKzIogKz4V1qf8PXAzcppZN22FarW6CTGq32U+YH6fQZOp2qz9BxE2QyIi0+XAVJcmqOQGers+PaoFSt3G58L60N5qZD+U270F6yPXoTA11hlnYwLEFP1mYtpJHAIiRS3T+9yIi3V2YjGBU4r28oBsZYtCDBtb6oAojvDnToDST0qjzJQNeSHLw6awG2bd+CP3WtwNROFuD4PiB9ORIrjuHyoPnA0vnAijuBbhOAg2uA8nzAHA2c8Sww5MLK7TQFAaOvh33QBXjnP3/FVY6f0Lt0A3pLACVlbPqP1RQCR3Qn2PKPIEiCFwlI5CQkMJH1TLLtMhPJk+BwLTDqdqLWTS9lGHB4LbD+E2DLt9r26SSQXv8/YP3HwMBzgJP+pmXbfCw3e+KnbeiXEl33/wXJ3snAXHVyDs+1lqjgKy8/Dxvnb8atplJEGUrRx5CBmNf/CpR7aOEtQV1k3dla8hN2O0Kt2u+bSbKnRNQuXHPNNfj999/V6YUXXlDXvffee7j22msxe/Zs3H///di0aRPmzp2LtLQ03HXXXVi+fDmKi4vRv39/PPnkk5gyZUqtpWsGgwFvvfUWfvrpJ/zyyy/o1KkTnnnmGfzpT3+qd9skuLrxxhuxYMECNaOoS5cuuOWWW3DHHXdUud+7776rnnP37t2Ij4/HmWeeiTfeeEPdJi2///73v+Pbb79Ffn4+evXqhX//+9/qPs2FgU47I4GAZD2kbGjNgVz8a5Yc4EKVoI2oI5DwlNWRQEfK17wNdPJKLLj63ZWqtXCfpEicO7zux4UEGXFy3474aeMR1Wa6zkAno2bZmnugI6R0Taev0akroyNknZAEOVK+Nr4nmpQMBt2WWVgloyPBlL6OSgZrThtY/9qkBotKAqKma13mPPjm15340LZLXf4hw4zfL5mEsBDv2jvaI5LwXkYijtpjcMGkE4A+zk+VrKVY8dt32LHoK0wP2YAkW3ZlMCIZmPPf1tpve7CnwIjHyy7Cp8FTMe/Ug3h/xWGsL4jC5aedhLHDhwERiaiw2TD7px8xY1Q3BB92ZrAyVgB5B7Sshk7K76TDnnwPTGbg4EotiNv7m3YSxiDV3MElJg32IZfgqjU9EVaRj9e6/oagXXOALbO0U5/TgNE3aFkhKf2rfirXg5UCdZ6bnYWrCnIRYqiAfUlYzX4YeoBTUfvCG/ltv0cuuMfD5c7ArmM/LVhLGaqtyQqte54T+ZHyfBihfVgTHMVAh6gpyIe7pdZaPuhqZmaTd7UREtzs3LkTgwYNwiOPPKKu27Jlizr/xz/+gaeffho9evRAXFwcMjIyMGPGDDz++OMwm8348MMPcdZZZ2HHjh0qCKnNww8/jKeeegr//e9/8dJLL+Hyyy/HgQMHVFBS30yczp0748svv1SziZYuXaoCHxnmedFFF6n7vPbaayr4kuDl9NNPR25urgqM9MfLdYWFhfjf//6Hnj17YuvWrQ1uG+0tBjrtjDQTkFIuWbh/00drVNZgcKcY/HVyb5+eR+bpvP77Hvy+8yhsdoca8FkXaV395w9WqxkqKTGh+OC6E7zKHkmbaQl0ZHbK3dNrX/ivtzAe4jaPR6cHEXuPFqHUYlMH694GOto6naPYX1tDgkbYc7QIlgq7ylp1ia/s9S9ZHQl0lu5p5kCnHu6DPbMLy1UZobdrsiQjJQFtRIgJY3u4/fEMDkP3cefg4gVR+D+bAxv/0hVRBxdqmZxhl1XtWFeN3la6Y+eeME26AjtzNuKH1RnoUtoNY6Wdt7DZtIP8pEFA5+HACTdo16uZRJlaRkMyO9VfR0raZB3Q/sXA/kXA/iWALAaXlt4DzgaGXQp0PVH9v1k8T3p/R2Ph8BcxZfJRYPGzWqCzc4528pLaYr07eNVRSp6ZY4DQGGfWLQLpRcCOHBssxlCcPLArCmzBeH2zAenm3njv79fCaG7fddkBzbkOrNhhRlQ7r68naioS5Ax48JdWee3ND0316n4xMTEICQlR82OSk7X3te3bt6tzCXymTq18HglMhg4d6vr60UcfxaxZs/D999/jtttuqzNrdOmll6rLTzzxBF588UWsXLkSp512Wp3bFhwcrIIkXffu3bFs2TJ88cUXrkDnsccew9/+9jdXlkeCm759tWO3X3/9Vb3Otm3b0KdPH3WdBG3NjYFOOy1fkwO2nGILzEFGPHfxUASbfJtYO6JLrJp0n1tixfqMXIzsWvsnARII3fHZOqw+kKseI0GOt2Vg0hhBYihpSSzlZlI2V12Fza4OrPV9q07aGneINONYUTm2ZxaozNARL9bo6BkdceCYW4vpJl6f0z81usr6I1mn87/l6aoTXmuRwHRtupYlkyD4xfm78PrCPbjshC5ercmSBhLi5D4dVSlh9Z9Hj44Rqr348qJETB1/u1fbtPaAtj0jusa5ftafr85QjTXqpc82qo00e0gaoJ3G3KgFPrn7tKyPW2e65W7d4mTt2JRzBwMXvAtM+hew+DltVlJQqLbuSErhpAwwJFy7LEFKaCwcodF4ZWk21h11oNARjnIE4/yRnXHV2GqZLCnZkyyMHtwYK7+Pq/Yfx8VvLIPdAfX/N2p4Z5jKyvHl5nkoKzFgU7YVQ+ueH0z+TNqrS+MWRCGac6KISMr5R42q8nVRUREeeughVYZ25MgRVFRUoLS0FOnpWlfb2gwZMsR1WRoVREdHIztbGwVRn1deeUWVpslryGtZLBbVOEHIcxw+fBiTJ0/2+Nj169erjJAe5LQUBjrtkFbepS1e/vtp/dArMcrn55D1K3IQ++PGI6rNdG2BjqSKH/5hC37ZkqVm1rx11Sj0SfL+9eSgemTXOKzan4sF27Jw5biaZU27JVNjtansQc+OntslS1ZHsk+yTqdnYiQKyytcDQfqondea46MzpZq63N0MmtGWmLLvJjsgjIkRte9jc1hXXqeyjYlRplxx+TemLc1C9uOFODVhbvxrzMG1Pv4eduyXfOQPBnTPUELdPbmqOG03tAzOnqJpZ69k/VZTd4VTwKfhJq1isvcslwLdxytHJor9z37Za+e+qvVGXg6a6OaR3XzKT3x/K+7gMwYXOWpBbkH+SVW3PHpOhXknDe8E84d3lldLx9W9IlxYONxg9o2T0E/BQgpo5RAxxHJgbhETSQs2IStj3gu1W6J0rVC7fPVBqvePe3uu+/GvHnzVDmbrHUJCwvDBRdcoIKP+jIz7uQ9TDIv9fnss8/Ua8r6m3HjxiEqKkqVv61YsULdLq9fl/puby6+fYxPbYIEKDIU9PRBybhmvOf1EN6Wr4nfth+t9T6v/74XHy47oA7cn7t4GMb0SGjA62gHwl+vPaSyN9VtdH6iP6hTTK0ldO7rdPSytbjw4HrL51wZnZwSdVDblLZU67jmHtxJeWH1A+vWKFuToEu+p/eepqWeP1h2wNXIoTZyuwRF8qOY1Ndzxxe9nE0Gh3pDSiz1QaHDu8S6ZiRJRrKwrKJZAlFPa6pW7z9eZT93ZlUOL/WGrI17YvY2dfnOKX1wyWitjnqjNJ8okYmxdZPfwX98sxGHnV0SHzlH2nVXGhCr/Y4u3Ondp3Pk36VruY4oRIcy0CFqCnJAL+/5rXHyNIC9NlK6Jgv/67NkyRJVhnbuuedi8ODBqtRt/35tHmJzWLJkCcaPH68aEAwfPlwFV3v27HHdLoGPND+YP39+rZmkgwcPqjVILYmBTjskQc7Kf07Gq5ePaNSn4Kf06agCGAkeMvPLqhyMZRWU4cNl+/GfOVpt6YNnDsAZQ1Ia9DpnDU1BeIhJdYp76IctNQIOvePasDo+wdaDCcnoeLs+R3SOC1cH7JIxkhbcTUUyEHpzBAnQqpvQS1uA3Frla+6BjpjYp6Ma9ilZnufn1f1HSjJveuZFH9DqKaMjpOV3QVn9B/jys9cDTylD1DMY+vfOvV16c5F1YCUWmwqQ5cMCvXzNF4//tE2Ve/ZLjsJ1J3ZHckyoGo4rv9LeBLUS7P+8OVM1FHnx0uE1hu32dwY60pxDWr9TgHIOC80DMzpE7Y0EC5IlkaDl2LFjtWZbevfujW+++UaVhG3YsAGXXXaZV5mZhpLXW716terWJsHKAw88oOb0uJNSOsn4yLqfXbt2Ye3atXjzzTfVbaeccgpOPvlknH/++SoTtW/fPvz888+YM8f7ta0NwUCnnZJPF3z5hMETOYjVg4t/zdqEmz9ag9OeX6QW+415Yj4e/E7rFHLTyT1w7YTuDX4dCTaev3iYCqpk7cr7S6t+YqEf5NY1k0fPkGw/UoD0nBKvAx3p/KaX2sk6o2JnyVtjHThegqLyCpWRkAPd6sb31AKBJbtzmjyT5M36nHXOwGKcczvkd+Xvp/dzzUHalaV1i2tI2ZqQA3zJSEj5lXuWpDZrD1QtW9O5yte8WafTRMGfBGky40lI2aa3ZDaSfO/k9/iJ8wa71sWd6ENQ+96Sfep85pQ+Hn/fY81A36RI9X39oxXXeFHj2Iq0nx1L14jaHykPk05kAwYMUHNwaltz8+yzz6rua5JlkW5r06dPx4gRI5ptu2666Sacd955uPjiizFmzBjk5OSo7I67q6++Wg06ffXVVzFw4EDVtto96/P1119j9OjRqhmC7N+9997rVfaqMbhGhxrl1L6Jaj3H/GoHfFLu1DkuDGcMTsHd02rvluYt6T523+n98MTs7Xj0x61q7Yy0uJaD8u1HCmvtuKaT+0tWSD6RX7xbO2D11NjAk6cuGILL316h1gld+94qvHftaERU+yTdnZTXLd59TB2IxteycF9fnyMzVGS9U3UndI9Xw0qlPEqGoXZxltBVfx3h6fFNsT4nKdqsghGdBBnTByap9VZP/bJDrbeqToK35Xu0768eDNRGAob9OSVYsfe4qzyx/vU5VQ/u9UC7JTI6lVmueNUkA9iiWrR7M+9Ifk//9a3Wyv2KMV2rBGySvZOSwCV76g5MdmcXqoyk/F5IU4janNS7A3ZkFWHhjmz8aWiqj3tJ/sBSdAxhzmYEkaF8myZqT2SxvnQzcyclap4yP3rrZt2tt95a5ev91UrZPH1wKrNtvCEtrGWmj5zcyeye6gGRnIRkmAoKCqp0ipNmBi2JGR1qlKvGdVPDDmWtz/+dNUAFAb/dPRHbHjkNv98zCfee1q/JFonfcFIPXDwqTX1affun61QHNVkLUmF3ICEiRAVWtZFtkBlCYvHuo141ItBJwPK/68eoNtAr9x/Hde+vQonFc2Zn86F8nP3KElzz3ipc897KWrMxm2tZn6OTml59LUr1A2Ape3t38T4Mfmgubv7fGjRn2Vr1rN890/uqUj5pTrDmQGUmRg72F+08qtafWGx2VWLWK9FzYwjdGOc6Hfc21p7I/uqla9VnKelZDQkAJDhrLvLcq/drwda4nh3UIFnZP+ko+Meu2teo6V5duEfNY5LmDvc41zvpZN2afE+lOYNeVunJ9+sPu0pG6+p8d0pvLUMkPw/53lHgsRVp/ydKg2pfd0hERPVjoEONEhMejCfPG4yH/jRQlafJJ93dO0Sokq+mJgfdj54zCON6JKjMwfXvr1aDRPVsTn2leHpQUWbVDoi9bXEtpIPVh9efoIKdFfuOq9eWmTw6uSwH+RLkyEG3vqZDul/50nHN3fieNUua5ED4yndX4JEft6p1Q79uy1bBVVNaVm19jjvp0HfhSK1v8QPfbsG9X23A1Gd/x7BH5uKqd1fikxVaiv20gcn1/jz0xhSbDxeon2dtpKueNByQjJysbXEnGSdpWS6ByM46yukaa+PBPPX9lgydDLsVeqOFuppxqO3PLsJrC3ery/L/pPricskG6QFbbeVrEjB/t0ELdP40rO4sjWS9pAPhsSKL63eRAovD2YzAEszOeUTUMm6++WZERkZ6PMltgYqBDgUUCaBeu2KECqakrOvl33bXuz6n+jodnTdrdNxJNuH9605QC8AlGLj+g1UqwJFP9Kc9/zveXLRXfcJ/5pAUXDJaCwZeXLCrRlZHvtYPQGvL6Lg3JFi2J0d9Mv/tukOY/vwitW5HWhP3da4d+tgZXDQFKbFa75yf4ynQETOn9lZri6SZwherD6puaLKLksU5Z1gqHj17IO6YUv8AWikdTIsPU9+zutbp6OtzJJitXqYnwZTeRlnP+jQH+RnoZWt6ACelk+L3ndl1Zk6emrMdVptDBUbS6dCTCb2077UMifVEgmbp/CftUetrxy3/R/TfHSlfo8BjcAY6VjMDHSJqGY888ohqbODpJLcFKhb/UsCJDQ/Bu9eMxjmvLFElU/V1XNMNrJY98XaNjjuZ6fPBdaNx1Tsr1UHp1Od+x8FcrdwoJSYUj50zSC3Czy4sw6x1h9R6FzlIHu888BSZBWWqzbCUpEiL5NrIPsmBrQx2veKdFa6DYLn+2YuGIruwHJe8uRzfrz+Ef53Rv0YHroaQtTBSelZ9fY47yYQ9fu5g/LTxsGrbPTwtTpXZ1dZhrb51OhnHD6os2US17sXzNnlqROA+F+qPXcdUp7GLR/q2JkXWOUmAJM9dV4nlcmcbbMkm6kZ1jVffc8mcyMBaT3NrJBM0d2uWKk2Tn1FtWS4JTF75bY9a2+WazePmO2fZmgQ59bVEF/K9lNdduPMobp9cf9BJ/sVUrv3O20N9b8dPRNQQiYmJ6tTWMKNDAUkyOq9fMVItzJZBpN4MR+ydFOmqd5fHSZvthpDhqB9cd4IqpZIgR45JZY3SvLtOcXUaS4wKVWuXxEsLtKxT9fU5vRMjERpcOe3e0yfzo7tr61gkyJFt/tvUPvjq5nHo0TFStXuWjm3FFhu+W38ITWH53uO1rs9xd8HIznjv2hNwz/R+mDIgqUFBjpB9ECvqWKez1plhqjXQcf7sJevhqyd/3o4LXl+mMm+1Ka+wudbnuGe55OcjC//r6r729FytFfc5wzvVOZhX9k2ydEcLy13zgnSS8fphoxbonF1P2ZpuorOsbl16LvJK2GbaXxVZPSwOdjgQYtF+5w3hngcxExGRdxjoUMCS1sezbpmAT28cW2t3M3cSVEhwobc3bswi31Hd4vHJDWNVidrXfxmv1l5Uz6jceHIPNe9EytzcS7P09TnVM0yeTHV2LpOF77Kv8um8Xr4lgchlY7qqyx8vT2+SNtR6YwD3zEVz0gMHCVIyjmttv93JEE1Z4yL05gzVDXV229uZXVjnWp/qjhWV43/LD6jL7/yxz5UdrE5aV5dX2NEhMqRGgwWt+5rnErGV+46rhgASoM6c3Kfe383R3eI9rtORIFACIFnLc1JvzwNYq5OyzD56m+ldbDPtj15ZuBcPrzXht53Vfj7WEpjsWnBqjGCgQ0TUGAx0KKAN7hyjysm8pa/T8XV9jidSQvbv84fUmmmQ15DMh9DXEnnTcc2dBDKzbhmPH28/Ue1rdeeP6KQyC7JeZkMDMhq+rs9patIpT76P0jlPmhnkFJVXuX1dhpZJkTK62rJGidGhqmxQ4jxfFt9/sHS/CmBEYXkFPlq2v871OWM8ZLn0zIl87yUY0UnQ+fQvO9Tli0aneWwP7u2QWL1sbcbgFJ+afOilgLU1xKDWJTO5LHYDnvt1d9U1XiXa75vFYUJoRP1/I4iIqHYMdKhdGeEMiuprfdxU/nJKL5U5koPNTc5AZKveca1T/Rkdeaw0QaitxE3WK505OEVd/mSFlp1o7Pqc5OhQ1VigJUjg8MaVI9V6KWm/LK273Yey1le25r5OR2xyBpH1kdf4cJn2/ZJZT+Kdxfs8tg2vK8slQdagTtrB6O87KwOKRbuOqVbkEpjcfmovr7ZJHxwq5YP6jCQpm5u9+YhPZWs6aUOtbxfbTPufG8anItZUhv2ZxzBn/V7AUqKdCrSft8zQiQmvP1NNRES1Y6BD7cpFo9Lw0qXDm2SIqTfkk/yznUMbX/5tl2pCcDi/TH3dP6X2NRu+uGyMthbohw1Hai2/8m19TmVnsZaQFB2qWnfHhQerzMgtH6+F1XmgL2tMxPB6snZD0mJ8Wqfz6cp09b2StV7PXTxMBXa5JVZXe2z3LNca5zbUluWSobniN+c6HcnmPDNXy+ZcObar123MJdsYGx6syu/07JwEyNJaW4LPE5ylbd4a1S1OrSOTEj3J+JF/SVjyKNYHX4ftoddixvcjgCdStNO709TtuY4oRNcziJaIiOrGQIfaFfmE/ayhqV6t6Wkqt0zqqRoW/LIlC9+sPaiukwPsqGrzVBpKSvdkPYbMeZEW1A213NVCueU7PfXsGKk66UmXOclA/P3rjWoRvl5KJ7Nh6jLMldGpP9CRmTuSvdHXUcnvxF9O6am+lhbhEtzopCOb3F8aV0jjB08mOttML9p1VAVo0u1MAi4JMv4yUXteb0jXt/E9E6qUr33vnJ1z1tAUnwfvmoNMrllM7tkmCgwL7MPVuiwiIl9069YNzz//fGtvht9goEPUzKTb1oxBWnnUf53rNqQtc1OR7MvlzqYEkpFoSFMCmQekz6FpjUBHSIneK5cPV+V636w9hNs+WavWzkjAoM8Mqs0gNTAWOJhXhsJ6kloSPBzJL1PBy7nDO6nrzhvRWa3zkZbdX67RgtGq83Nq70InZXMSOEvmZdX+43jW2Wnt2gnd0MHHbnR6YCJtpiWz8+vWLPX12cO07fSVvoaI83T8j33KI/hxyFt468Q/0L/sXUw2f4ryezOAfx7GefFf46mKS5jRISJqJAY6RC3g1knaOg198fsgLzqu+ULaF0t74h1ZhViX4XtTgnWtsD7Hk1P7JeHf5w1Wl3/enOkKJKoPCq0uOjQYPTpoGZf0otozH7JW5Y3f96jL103o7lr7JFmdm07uoS6/vnCPq3TOmy50Epjp62Ee/G6L+hlEhQbhxpO8z+ZUX6cjPw/JzsnvS4+OEV41rqgr0JG1To0pa6RmEGSGzWTGJeP7ICoqBnvyHfh8w3EgJAJHy4yu32siImo4BjpELUAyOFOcraJFQw9cayMlLmcN0dYCfboyw+N9pCRrd3ahKgmrznVA37Pu+Tkt4cJRabj3tMo1VCO6ejcdXp+nU1egI/NuZE5NlDkIl4/V1jbpLjmhi2ohfSivVHU6k++XDHzV1y3VZZKzfE1vhS1BU0y47wepEmRKYwarrXKdz5+Gpjb4Z9I5Llw9XhoisCGBf5JgW29YITO3JLsqbdUFS9eI2pc333wTqampsNu1D9t0Z599Nq677jrs2bNHXU5KSkJkZCRGjx6NX3/9tcGv9+yzz2Lw4MGIiIhAWloabrnlFhQVVZ3ltmTJEkycOBHh4eGIi4vD9OnTkZvrHGpst+Opp55Cr169YDab0aVLFzz++OPwJwx0iFo4qyPHrE0d6Lg3JZi9JQvFbh/ey4H7f+Zsx7gn52PKs4vU+eM/bVXzfPQyN/dGBP5A1szcMrGnCjxkTZU3pE21OFD1b3QVrzmzOZeP7Vrj03I54PzzSVpW59XfdqshoZLlSoo2qzVVdTm5dwfoS2gSIkJw7YTuaAgJaCb00rJH0hxBSKDSGC9eOhwzp/RBXAuuSyPfXDy6i2q1Li3K31u6T5VsiuiwqrO5iKgR5P3OUtw6Jy9Lyi+88ELk5OTgt99+c113/PhxzJkzB5dffrkKQmbMmIH58+dj3bp1OO2003DWWWchPb1qIx1vGY1GvPjii9iyZQs++OADLFiwAPfee6/r9vXr12Py5MkYMGAAli1bhsWLF6vXs9m0taz33Xcf/v3vf+OBBx7A1q1b8cknn6ggzJ/wryhRC65BefK8wWqAZG0zYRpDDvT7p0Rj25ECrDxqQJd9x/HxyoP4ZUumGhwp5GBc1qG89cc+dZImBrL+o7XX53g64L/3tH7q5K0hzoYEO/INeHz2dtwxpW+Vg3tZP7PmQC5CTEZcN6Gbx+e4YmxXvLZwD/YeK8bjs7e5ytbqy6hIm+8x3RPUcFhpQBBRbXisL2SezhertXVCQzrHoEfHlmmFTq1HSifvmNwb93y1Ea/+tsd1TMSMDlETspYATzTug6MG+0fl2s+6SMbk9NNPVwGDBBjiq6++QocOHTBp0iQVmAwdOtR1/0cffRSzZs3C999/j9tuu83nzZo5c2aVJgaPPfYYbr75Zrz66qvqOsnWjBo1yvW1GDhwoDovLCzECy+8gJdffhlXX321uq5nz5448cQT4U+Y0SFqQZee0EWVZjUHrSmBltX57oARV7y7Wq1zkSBHDtZfv2Iktjx8Gt68ciRmDE5WB1c7s4pUgwTJXMhi/C7xrbc+p7GGdIrBGYOSYXcY8P6ydJz839/Uehy9i5qsvRHnj+yk5t94EmkOwjXjtSBIAkZfgr+nLxqqsiey9qcx9IYETZHNocAhjTGks580oRCy5k465xFR+yKZm6+//hrl5doQ6o8//hiXXHKJCnIko3P33Xejf//+iI2NVeVr27Zta3BG59dff1UBVadOnRAVFYUrr7xSZZRKSkqqZHQ8kdeVbaztdn/BjA5RGyJNCZ78eRuKy20ICzbi3BGdcfW4buibXNm1bNrAZHWSxelzNh/BrHWHVOnaBSM7t/r6nMaQ9svPXzwEXWyH8NvxGGzPKsKTP29Xg0GvHNcV87dnq7LBG5zlabWRbmlv/7EXxRaba92SN2RtjZwaS7rBTemfhI0H8xrcbY0CjzTcuGtqX9z6yVr1NRsREDWx4HDV1bBVmEKBskKv7iqlYVJW/tNPP6k1OH/88Qeee+45dZsEOfPmzcPTTz+t1sWEhYXhggsugMVi8XmT9u/fjzPPPBN/+ctf1Lqa+Ph4VZp2/fXXq+eTNTny/LWp6zZ/wkCHqA2RjMS7V43ErPnLcPclk9AhuvYMjZTFyNoAOVXY7PV2NgsU/WIduOOScfhhUxaenrtDrVH698/b1W2nDUyutxRMytCuGNcVb/y+t9WyXG9dNVKVL/k6O4cC2+mDktXgWBnwyrI1oiYmn3SF1L3estlUay5Ql9DQUJx33nkqk7N792707dsXI0aMcDUGuOaaa3DuueeqryXDIwFLQ6xZs0Y1E3jmmWdUtkh88cUXVe4zZMgQtR7o4YcfrvH43r17/397dwJbRf0tcPxgoRRsoUKhLWWXgghYH2BJIbb8pUKBJ5tBLPBYwhKgIKASHiBlU9kCopWEqA/QyFJRlmiMguzKYliEEKQRHlj2xQAtS6HLvJzf/91rW+4V2gLtnfl+kgnM3LntnDvTOfc3v9+cMY0dfX3o0KFSVtHQAWxGH655IdQq0hcluzRy8pd81iGC//lcLfmfn//X3HejlcxGtf93QYj7GRXXSM5dy5KXnw0tlV4u/Z0+3LmGYtKG7X93fkYGLfvV3G8HwLnD17S3RYsE9O/fv0DjYu3atabXR/OEFgEoXKHtQTVq1Eiys7MlJSXF/DxtRC1ZsqTAOlpsQKuyaTU2vXfH39/fFErQogl639DEiRNN8QJd3q5dO7l8+bLZZu0VKito6ACwrUr+fjL6pUj5r5j6kpmVbcotPwgtDZ2S+B+PfPuAwmIb15DtE/5V5IfNArCPl156yQwlS0tLk759+xYoB61lptu2betuaGRk/Pt+0qKKiooyP2/u3LmmQRMbGyuzZ8+WAQMGuNdp3LixbNy4USZPnizR0dGmB6dNmzaSmJhoXteGVvny5SU5OVnOnTsn4eHhpkFUltDQAWB72rvFUCD4ijo+XBQEQMnpUDJtOBSmldG0BHR+SUlJBeaLMpRt/PjxZspPCxLkFxcXZ3p7vG3nlClTzFRW2Wu8CgAAAADQ0AEAAADsRYsZBAYGepxcz8JxAoauAQAAADbSrVs3cz+NJxUqOGcoNw0dAAAAwEb0AaBBQX8/Q8+pGLoGAAAAwHZo6AAAAMB2LH3yMhy9/2joAAAAwDZc96DcunWrtDcFJeDafyW5p4h7dAAAAGAbfn5+EhwcLJcuXTLzlStXlnLlypXa9uTl5cndu3clKyvLPHvGKfKKGbf25GgjR/ef7kfdn8VFQwcAAAC2EhYWZv51NXZKk35xv337tlSqVKlUG1y+Frc2clz7sbho6AAAAMBW9It1eHi41KxZU7Kzs0t1W/T379ixQ2JjYx1V2jm7BHHr+iXpySlRQ2fx4sUyf/58uXDhgkRFRUlKSopER0d7XX/NmjUydepUOXXqlERGRsrcuXOlS5cuJdluAAAA4B/pl+WH8YW5pNuQk5MjAQEBjmro+JWBuIs8UDA1NVXefPNNmTZtmhw4cMA0dDp16uS1a3DXrl2SmJgoQ4YMkYMHD0qPHj3MdOTIkYex/QAAAABQ8obOwoULZdiwYTJ48GB59tlnZcmSJeYmr6VLl3pc/8MPP5SEhASZMGGCNG3aVGbNmiUtW7aUjz/+uKi/GgAAAAAe/tA1rZywf/9+mTRpknuZVlGIj4+X3bt3e3yPLtceoPy0B2j9+vVef8+dO3fM5JKRkeEe61eccZau95T2GM3S4NTYnRq3InZifxQ/FwAAWzd0rly5Irm5uRIaGlpguc4fO3bM43v0Ph5P6+tyb2bPni0zZsy4Z7k2jrT3qLg2bNggTuXU2J0atyJ2Z3rYsbueY8CD9wpyfR6uC3HFaUDqZ6vvd9KYfUXsxE7szpD9CON2nXvvl5vKZNU17THK3wt09uxZM0xu6NChpbpdAOBUmZmZUrVq1dLejDL1eag6deqU9qYAgGNl3ic3FamhExISYiooXLx4scBynfdW51qXF2V9VbFiRTO5BAYGyunTpyUoKKhYdbi11afJSH9GlSpVxEmcGrtT41bETuwPM3a9WqaJpFatWg/tZ9qBfh7kpeIhdmIndmfIeIRxP2huKlJDx9/fX1q1aiWbN282ldNcTz3V+dGjR3t8T0xMjHl93Lhx7mWbNm0yyx+U3gdUu3ZtKSn9kJ10gOXn1NidGrcidmJ/WOjJuRd5qeSIndidxqmxV3lEcT9Ibiry0DUdUjZw4EBp3bq1eXbOokWL5ObNm6YKmxowYIBERESY+2zU2LFjJS4uThYsWCBdu3aV1atXy759++STTz4pTkwAAAAA8PAbOn369JHLly9LcnKyKSjw/PPPyw8//OAuOJCenm6udLm0bdtWVq5cKe+8845MnjzZPDBUiwo0b968qL8aAAAAAB5IsYoR6DA1b0PVtm3bds+y3r17m6m06P0++oDT/Pf9OIVTY3dq3IrYiR1ln5P3F7ETu9M4NfaKZSDuchY1QwEAAADYzN9jzAAAAADAJmjoAAAAALAdGjoAAAAAbMdRDR19qJtWfHMap8btyalTp8zn8dtvv4nTODl2LZKisV+7dk2cxsmx+wqnnqOdGrcnTj4/Ozl2J5+ftz2m2G3X0Fm8eLHUr19fAgICpE2bNvLrr7+K3U2fPt0cLPmnZ555Ruxox44d8sorr5gn4XpKklpbQ0ufh4eHS6VKlSQ+Pl7++OMPcULsgwYNuuc4SEhIEF+nz+R64YUXzBPoa9asaR5WnJaWVmCdrKwsSUpKkurVq0tgYKC8+uqrcvHiRfF1DxJ7+/bt79nvI0aMKLVthmfkJnITuYncRG4a8di31VYNndTUVPNAUy1ld+DAAYmKipJOnTrJpUuXxO6aNWsm58+fd08///yz2JE+nFb3q35p8GTevHny0UcfyZIlS2Tv3r3y5JNPmmNATzZ2j11p8sh/HKxatUp83fbt202i2LNnj2zatEmys7OlY8eO5vNwGT9+vHz77beyZs0as/65c+ekV69e4oTY1bBhwwrsd/07QNlBbiI3kZvITeSm86WTmywbiY6OtpKSktzzubm5Vq1atazZs2ebeQ133bp17teTk5OtsLAw69ChQ5YvmzZtmhUVFeX1dbvGXTiuvLw8E9f8+fPdy65du2ZVrFjRWrVqlZk/efKked/BgwfNfE5OjjV48GCrSZMm1p9//mn5auxq4MCBVvfu3b2+xy6xX7p0ycSxfft29z6uUKGCtWbNGvc6v//+u1ln9+7dZn7r1q1m/urVq2b+5s2bVkJCgtW2bVv3Ml+MXcXFxVljx471+h67xO7LyE2e2TVuchO5SZGb4spEbrJNj87du3dl//79pjvY5YknnjDzu3fvLrCu/i2OGTNGvvjiC9m5c6c899xz4uu0C1y7jRs2bCj9+vWT9PT0e9axY9z5nTx5Ui5cuFDgGKhataoZJlL4GFB37twxD7LVccH6edStW1fsMOZVu5GbNGkiI0eOlL/++svjer4c+/Xr182/1apVM//q371eTcq/33V4jMbkab/reOCXX35Z8vLyzJWo4OBg8dXYXVasWCEhISHSvHlzmTRpkty6dcvj+305dl9FbiI3kZvITS7kplse3/8oYy8vNnHlyhXJzc2V0NDQAst1/tixY+75nJwc6d+/vxw8eNB0oUdERIiv05Pl8uXLzQlEuwZnzJghL774ohw5csSMn7Rr3IVpIlGejgHXay43btyQrl27mpPq1q1bTdLxdTo0QLvEGzRoICdOnJDJkydL586dzQnVz8/PFrHrSXDcuHHSrl07c+JUum/9/f3vOTF62u8636dPH4mMjJSVK1ea9/ly7Kpv375Sr14982Xy8OHDMnHiRDNWeu3atbaJ3ZeRm8hN5CZyU37kprWPNXbbNHQelI6XrFixohlXqK1MO9AThoteCdPkogfXV199JUOGDLFt3CWRmJgotWvXli1btpgbQ+3g9ddfd/+/RYsW5lh4+umnzZW0Dh062CJ2HROsX5KKO85frxhFR0ebeybyJ1hfjn348OEF9rve7Kz7W79Q6P63Q+xOYMdzNLmp6Hz5/OwNuen+fPn8nFTGc5Nthq7pCVI/oMLVLHQ+LCyswAd69uxZ+fHHH8Wu9OpB48aN5fjx446K27Wf73cMqC5dupgrDJ66j+1Ch4ro30X+48CXYx89erR899135kqfJkMX3bc6PKhwiUpP+12vFmqFoKNHj4odYvdEv0yqwvvdV2P3deSmv5GbyE2K3ERuepyx26aho11drVq1ks2bNxfoTtP5mJgY97Ju3bqZrrGhQ4fK6tWrxY60+1dbzNp6dlLc2i2uJ4/8x0BGRoapcJP/GFA6RnjOnDnmc9HqIXZ05swZMw46/3Hgi7Hr+H09ma5bt85c6dP9nJ/+3VeoUKHAftfucb0XoPB+17gHDhxorir5QkK5X+yeuJ5FUXi/+1rsdkFu+hu5idykyE3kpscau2Ujq1evNlVMli9fbh09etQaPny4FRwcbF24cOGeaiBaBSMgIKBANQxf9dZbb1nbtm0zlUt++eUXKz4+3goJCTFVMOwWd2ZmpqnMopPGtXDhQvN/V2WWOXPmmH2+YcMG6/Dhw6bSS4MGDazbt297rO7ywQcfWIGBgdbOnTstX45dX3v77bdNJReN8aeffrJatmxpRUZGWllZWT4d+8iRI62qVauaY/z8+fPu6datW+51RowYYdWtW9fasmWLtW/fPismJsZM3qq7jBs3zgoNDTUVcHw59uPHj1szZ840Mev+1eO+YcOGVmxsrM/HbifkJnITuYncRG5qWCq5yVYNHZWSkmIOKn9/f1PSc8+ePV7LHqamppoT6zfffGP5sj59+ljh4eEm5oiICDOvB5kd43b9YRSetHylq4zn1KlTzR+LfrHo0KGDlZaW5n5/4ROqWrBggRUUFGQSsa/GrieXjh07WjVq1DDlLOvVq2cNGzbM/UXKl2P3FLNOy5Ytc6+jXxZGjRplPfXUU1blypWtnj17mpOutxOqGjNmjPm7yX98+Frs6enpJnFUq1bNHO+NGjWyJkyYYF2/ft3nY7cbchO5idxEbiI3XX/ssZf7/w0GAAAAANuwzT06AAAAAOBCQwcAAACA7dDQAQAAAGA7NHQAAAAA2A4NHQAAAAC2Q0MHAAAAgO3Q0AEAAABgOzR0AAAAANgODR3gIRk0aJD06NGjtDcDAACDvASno6EDAAAAwHZo6ABF9PXXX0uLFi2kUqVKUr16dYmPj5cJEybI559/Lhs2bJBy5cqZadu2bWb906dPy2uvvSbBwcFSrVo16d69u5w6deqeK24zZsyQGjVqSJUqVWTEiBFy9+7dUowSAOAryEuAZ+W9LAfgwfnz5yUxMVHmzZsnPXv2lMzMTNm5c6cMGDBA0tPTJSMjQ5YtW2bW1eSRnZ0tnTp1kpiYGLNe+fLl5d1335WEhAQ5fPiw+Pv7m3U3b94sAQEBJglpshk8eLBJVu+9914pRwwAKMvIS4B3NHSAIiaUnJwc6dWrl9SrV88s06toSq+k3blzR8LCwtzrf/nll5KXlyefffaZuZqmNOHoVTRNHh07djTLNLEsXbpUKleuLM2aNZOZM2eaq3GzZs2SJ56g4xUA4Bl5CfCOIxUogqioKOnQoYNJIr1795ZPP/1Url696nX9Q4cOyfHjxyUoKEgCAwPNpFfUsrKy5MSJEwV+riYTF73SduPGDTO8AAAAb8hLgHf06ABF4OfnJ5s2bZJdu3bJxo0bJSUlRaZMmSJ79+71uL4mhVatWsmKFSvueU3HPQMAUBLkJcA7GjpAEWlXf7t27cyUnJxshgqsW7fOdPPn5uYWWLdly5aSmpoqNWvWNDdz/tMVttu3b5thBmrPnj3mKludOnUeeTwAAN9GXgI8Y+gaUAR6hez999+Xffv2mZs8165dK5cvX5amTZtK/fr1zY2caWlpcuXKFXPDZ79+/SQkJMRUtNGbPk+ePGnGQL/xxhty5swZ98/VSjZDhgyRo0ePyvfffy/Tpk2T0aNHMw4aAPCPyEuAd/ToAEWgV7927NghixYtMpVs9KrZggULpHPnztK6dWuTLPRfHRqwdetWad++vVl/4sSJ5kZRrYYTERFhxlPnv5Km85GRkRIbG2tuHNUKOtOnTy/VWAEAZR95CfCunGVZ1j+8DuAR0+cVXLt2TdavX1/amwIAAHkJtkH/IwAAAADboaEDAAAAwHYYugYAAADAdujRAQAAAGA7NHQAAAAA2A4NHQAAAAC2Q0MHAAAAgO3Q0AEAAABgOzR0AAAAANgODR0AAAAAtkNDBwAAAIDt0NABAAAAIHbzf3Wr1IXdI/3RAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curves(history,sample_step=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(90.45, 0.2871047932624817)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_accuracy=evaluate_model(model,test_loader,device,criterion)\n",
    "test_accuracy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
